@gtkx/ffi 0.8.0 → 0.9.1

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

@@ -1,7 +1,8 @@
 import { call } from "../../batch.js";
-import { NativeError } from "../../native-error.js";
-import { getObject, getBoxed, getInterface, isInstantiating, setInstantiating, } from "../../native.js";
-import { registerType } from "../../registry.js";
+import { NativeError } from "../../native/error.js";
+import { getObject } from "../../native/object.js";
+import { isInstantiating, setInstantiating } from "../../native/base.js";
+import { registerNativeClass, getNativeClass } from "../../registry.js";
 import { DBusInterfaceInfo } from "./dbus-interface-info.js";
 import { DBusObject } from "./dbus-object.js";
 import * as GLib from "../glib/index.js";
@@ -59,24 +60,23 @@ import * as GObject from "../gobject/index.js";
 const SIGNAL_META = {
     "g-properties-changed": {
         params: [
-            { type: { type: "boxed", borrowed: true, innerType: "GVariant" } },
-            {
-                type: { type: "array", itemType: { type: "string", borrowed: false } },
-            },
+            { type: "boxed", borrowed: true, innerType: "GVariant" },
+            { type: "array", itemType: { type: "string", borrowed: false } },
         ],
         returnType: { type: "undefined" },
     },
     "g-signal": {
         params: [
-            { type: { type: "string", borrowed: false } },
-            { type: { type: "string", borrowed: false } },
-            { type: { type: "boxed", borrowed: true, innerType: "GVariant" } },
+            { type: "string", borrowed: false },
+            { type: "string", borrowed: false },
+            { type: "boxed", borrowed: true, innerType: "GVariant" },
         ],
         returnType: { type: "undefined" },
     },
 };
 export class DBusProxy extends GObject.GObject {
     static glibTypeName = "GDBusProxy";
+    static objectType = "gobject";
     /**
      * Finishes creating a #GDBusProxy.
      * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new().
@@ -281,253 +281,6 @@ export class DBusProxy extends GObject.GObject {
         }
         return getObject(ptr);
     }
-    /**
-     * Creates a proxy for accessing `interface_name` on the remote object
-     * at `object_path` owned by `name` at `connection` and asynchronously
-     * loads D-Bus properties unless the
-     * %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to
-     * the #GDBusProxy::g-properties-changed signal to get notified about
-     * property changes.
-     *
-     * If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
-     * match rules for signals. Connect to the #GDBusProxy::g-signal signal
-     * to handle signals from the remote object.
-     *
-     * If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and
-     * %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is
-     * guaranteed to complete immediately without blocking.
-     *
-     * If `name` is a well-known name and the
-     * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION
-     * flags aren't set and no name owner currently exists, the message bus
-     * will be requested to launch a name owner for the name.
-     *
-     * This is a failable asynchronous constructor - when the proxy is
-     * ready, `callback` will be invoked and you can use
-     * g_dbus_proxy_new_finish() to get the result.
-     *
-     * See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
-     *
-     * #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
-     * @param connection - A #GDBusConnection.
-     * @param flags - Flags used when constructing the proxy.
-     * @param info - A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
-     * @param name - A bus name (well-known or unique) or %NULL if `connection` is not a message bus connection.
-     * @param objectPath - An object path.
-     * @param interfaceName - A D-Bus interface name.
-     * @param cancellable - A #GCancellable or %NULL.
-     * @param callback - Callback function to invoke when the proxy is ready.
-     * @param userData - User data to pass to @callback.
-     */
-    static _new(connection, flags, objectPath, interfaceName, info, name, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_proxy_new", [
-            {
-                type: { type: "gobject", borrowed: true },
-                value: connection?.id ?? connection,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GDBusInterfaceInfo",
-                    lib: "libgio-2.0.so.0",
-                },
-                value: info?.id ?? info,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: name,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-            },
-            {
-                type: { type: "string" },
-                value: interfaceName,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * Like g_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
-     *
-     * #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
-     * @param busType - A #GBusType.
-     * @param flags - Flags used when constructing the proxy.
-     * @param info - A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
-     * @param name - A bus name (well-known or unique).
-     * @param objectPath - An object path.
-     * @param interfaceName - A D-Bus interface name.
-     * @param cancellable - A #GCancellable or %NULL.
-     * @param callback - Callback function to invoke when the proxy is ready.
-     * @param userData - User data to pass to @callback.
-     */
-    static newForBus(busType, flags, name, objectPath, interfaceName, info, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_proxy_new_for_bus", [
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: busType,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GDBusInterfaceInfo",
-                    lib: "libgio-2.0.so.0",
-                },
-                value: info?.id ?? info,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: name,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-            },
-            {
-                type: { type: "string" },
-                value: interfaceName,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * Asynchronously invokes the `method_name` method on @proxy.
-     *
-     * If `method_name` contains any dots, then `name` is split into interface and
-     * method name parts. This allows using `proxy` for invoking methods on
-     * other interfaces.
-     *
-     * If the #GDBusConnection associated with `proxy` is closed then
-     * the operation will fail with %G_IO_ERROR_CLOSED. If
-     * `cancellable` is canceled, the operation will fail with
-     * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
-     * compatible with the D-Bus protocol, the operation fails with
-     * %G_IO_ERROR_INVALID_ARGUMENT.
-     *
-     * If the `parameters` #GVariant is floating, it is consumed. This allows
-     * convenient 'inline' use of g_variant_new(), e.g.:
-     * |[<!-- language="C" -->
-     * g_dbus_proxy_call (proxy,
-     * "TwoStrings",
-     * g_variant_new ("(ss)",
-     * "Thing One",
-     * "Thing Two"),
-     * G_DBUS_CALL_FLAGS_NONE,
-     * -1,
-     * NULL,
-     * (GAsyncReadyCallback) two_strings_done,
-     * &data);
-     * ]|
-     *
-     * If `proxy` has an expected interface (see
-     * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
-     * then the return value is checked against the return type.
-     *
-     * This is an asynchronous method. When the operation is finished,
-     * `callback` will be invoked in the thread-default main context
-     * (see [method@GLib.MainContext.push_thread_default])
-     * of the thread you are calling this method from.
-     * You can then call g_dbus_proxy_call_finish() to get the result of
-     * the operation. See g_dbus_proxy_call_sync() for the synchronous
-     * version of this method.
-     *
-     * If `callback` is %NULL then the D-Bus method call message will be sent with
-     * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
-     * @param methodName - Name of method to invoke.
-     * @param parameters - A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
-     * @param flags - Flags from the #GDBusCallFlags enumeration.
-     * @param timeoutMsec - The timeout in milliseconds (with %G_MAXINT meaning
-     * @param cancellable - A #GCancellable or %NULL.
-     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't
-     * @param userData - The data to pass to @callback.
-     */
-    call(methodName, flags, timeoutMsec, parameters, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_proxy_call", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: methodName,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgio-2.0.so.0",
-                },
-                value: parameters?.id ?? parameters,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: timeoutMsec,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes an operation started with g_dbus_proxy_call().
      * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call().
@@ -563,7 +316,7 @@ export class DBusProxy extends GObject.GObject {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getBoxed(ptr, GLib.Variant);
+        return getObject(ptr, GLib.Variant);
     }
     /**
      * Synchronously invokes the `method_name` method on @proxy.
@@ -660,70 +413,7 @@ export class DBusProxy extends GObject.GObject {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getBoxed(ptr, GLib.Variant);
-    }
-    /**
-     * Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
-     *
-     * This method is only available on UNIX.
-     * @param methodName - Name of method to invoke.
-     * @param parameters - A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
-     * @param flags - Flags from the #GDBusCallFlags enumeration.
-     * @param timeoutMsec - The timeout in milliseconds (with %G_MAXINT meaning
-     * @param fdList - A #GUnixFDList or %NULL.
-     * @param cancellable - A #GCancellable or %NULL.
-     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't
-     * @param userData - The data to pass to @callback.
-     */
-    callWithUnixFdList(methodName, flags, timeoutMsec, parameters, fdList, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_proxy_call_with_unix_fd_list", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: methodName,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariant",
-                    lib: "libgio-2.0.so.0",
-                },
-                value: parameters?.id ?? parameters,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: timeoutMsec,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: fdList?.id ?? fdList,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
+        return getObject(ptr, GLib.Variant);
     }
     /**
      * Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list().
@@ -768,7 +458,7 @@ export class DBusProxy extends GObject.GObject {
         }
         if (outFdList)
             outFdList.value = getObject(outFdList.value);
-        return getBoxed(ptr, GLib.Variant);
+        return getObject(ptr, GLib.Variant);
     }
     /**
      * Like g_dbus_proxy_call_sync() but also takes and returns #GUnixFDList objects.
@@ -848,7 +538,7 @@ export class DBusProxy extends GObject.GObject {
         }
         if (outFdList)
             outFdList.value = getObject(outFdList.value);
-        return getBoxed(ptr, GLib.Variant);
+        return getObject(ptr, GLib.Variant);
     }
     /**
      * Looks up the value for a property from the cache. This call does no
@@ -877,7 +567,7 @@ export class DBusProxy extends GObject.GObject {
         });
         if (ptr === null)
             return null;
-        return getBoxed(ptr, GLib.Variant);
+        return getObject(ptr, GLib.Variant);
     }
     /**
      * Gets the names of all cached properties on @proxy.
@@ -947,7 +637,7 @@ export class DBusProxy extends GObject.GObject {
         });
         if (ptr === null)
             return null;
-        return getBoxed(ptr, DBusInterfaceInfo);
+        return getObject(ptr, DBusInterfaceInfo);
     }
     /**
      * Gets the D-Bus interface name `proxy` is for.
@@ -1102,75 +792,6 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
-    /**
-     * Starts asynchronous initialization of the object implementing the
-     * interface. This must be done before any real use of the object after
-     * initial construction. If the object also implements #GInitable you can
-     * optionally call g_initable_init() instead.
-     *
-     * This method is intended for language bindings. If writing in C,
-     * g_async_initable_new_async() should typically be used instead.
-     *
-     * When the initialization is finished, `callback` will be called. You can
-     * then call g_async_initable_init_finish() to get the result of the
-     * initialization.
-     *
-     * Implementations may also support cancellation. If `cancellable` is not
-     * %NULL, then initialization can be cancelled by triggering the cancellable
-     * object from another thread. If the operation was cancelled, the error
-     * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
-     * the object doesn't support cancellable initialization, the error
-     * %G_IO_ERROR_NOT_SUPPORTED will be returned.
-     *
-     * As with #GInitable, if the object is not initialized, or initialization
-     * returns with an error, then all operations on the object except
-     * g_object_ref() and g_object_unref() are considered to be invalid, and
-     * have undefined behaviour. They will often fail with g_critical() or
-     * g_warning(), but this must not be relied on.
-     *
-     * Callers should not assume that a class which implements #GAsyncInitable can
-     * be initialized multiple times; for more information, see g_initable_init().
-     * If a class explicitly supports being initialized multiple times,
-     * implementation requires yielding all subsequent calls to init_async() on the
-     * results of the first call.
-     *
-     * For classes that also support the #GInitable interface, the default
-     * implementation of this method will run the g_initable_init() function
-     * in a thread, so if you want to support asynchronous initialization via
-     * threads, just implement the #GAsyncInitable interface without overriding
-     * any interface methods.
-     * @param ioPriority - the I/O priority of the operation
-     * @param cancellable - optional #GCancellable object, %NULL to ignore.
-     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
-     * @param userData - the data to pass to callback function
-     */
-    initAsync(ioPriority, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_async_initable_init_async", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: ioPriority,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-        ], { type: "undefined" });
-    }
     /**
      * Finishes asynchronous initialization and returns the result.
      * See g_async_initable_init_async().
@@ -1249,7 +870,7 @@ export class DBusProxy extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         if (ptr === null)
             return null;
-        return getInterface(ptr, DBusObject);
+        return getObject(ptr, DBusObject);
     }
     /**
      * Gets D-Bus introspection information for the D-Bus interface
@@ -1267,7 +888,7 @@ export class DBusProxy extends GObject.GObject {
             innerType: "GDBusInterfaceInfo",
             lib: "libgio-2.0.so.0",
         });
-        return getBoxed(ptr, DBusInterfaceInfo);
+        return getObject(ptr, DBusInterfaceInfo);
     }
     /**
      * Sets the #GDBusObject for `interface_` to @object.
@@ -1361,9 +982,7 @@ export class DBusProxy extends GObject.GObject {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta
-            ? [selfType, ...meta.params.map((m) => m.type)]
-            : [selfType];
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getObject(args[0]);
@@ -1371,9 +990,13 @@ export class DBusProxy extends GObject.GObject {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.params.map((m, i) => {
-                if (m.getCls && signalArgs[i] != null) {
+                if (m.type === "gobject" && signalArgs[i] != null) {
                     return getObject(signalArgs[i]);
                 }
+                if (m.type === "boxed" && signalArgs[i] != null) {
+                    const cls = getNativeClass(m.innerType);
+                    return cls ? getObject(signalArgs[i], cls) : signalArgs[i];
+                }
                 return signalArgs[i];
             });
             return handler(self, ...wrapped);
@@ -1389,4 +1012,4 @@ export class DBusProxy extends GObject.GObject {
         ], { type: "int", size: 64, unsigned: true });
     }
 }
-registerType(DBusProxy);
+registerNativeClass(DBusProxy);

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

@@ -5,6 +5,7 @@ import { DBusConnection } from "./dbus-connection.js";
 import * as GObject from "../gobject/index.js";
 export declare class DBusServer extends GObject.GObject {
     static readonly glibTypeName: string;
+    static readonly objectType: "gobject";
     /**
      * Creates a new D-Bus server that listens on the first address in
      * `address` that works.
@@ -32,7 +33,7 @@ export declare class DBusServer extends GObject.GObject {
      * @param observer - A #GDBusAuthObserver or %NULL.
      * @param cancellable - A #GCancellable or %NULL.
      */
-    constructor(address: string, flags: DBusServerFlags, guid: string, observer?: DBusAuthObserver | null, cancellable?: Cancellable | null);
+    constructor(address: string, flags: DBusServerFlags, guid: string, observer?: DBusAuthObserver, cancellable?: Cancellable);
     /**
      * Gets a
      * D-Bus address
@@ -102,7 +103,7 @@ export declare class DBusServer extends GObject.GObject {
      * instance.
      * @param cancellable - optional #GCancellable object, %NULL to ignore.
      */
-    init(cancellable?: Cancellable | null): boolean;
+    init(cancellable?: Cancellable): 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,8 +1,8 @@
 import { call } from "../../batch.js";
-import { NativeError } from "../../native-error.js";
-import { getObject, isInstantiating, setInstantiating } from "../../native.js";
-import { registerType } from "../../registry.js";
-import { DBusConnection } from "./dbus-connection.js";
+import { NativeError } from "../../native/error.js";
+import { getObject } from "../../native/object.js";
+import { isInstantiating, setInstantiating } from "../../native/base.js";
+import { registerNativeClass } from "../../registry.js";
 import * as GObject from "../gobject/index.js";
 /**
  * `GDBusServer` is a helper for listening to and accepting D-Bus
@@ -28,17 +28,13 @@ import * as GObject from "../gobject/index.js";
  */
 const SIGNAL_META = {
     "new-connection": {
-        params: [
-            {
-                type: { type: "gobject", borrowed: true },
-                getCls: () => DBusConnection,
-            },
-        ],
+        params: [{ type: "gobject", borrowed: true }],
         returnType: { type: "boolean" },
     },
 };
 export class DBusServer extends GObject.GObject {
     static glibTypeName = "GDBusServer";
+    static objectType = "gobject";
     /**
      * Creates a new D-Bus server that listens on the first address in
      * `address` that works.
@@ -245,9 +241,7 @@ export class DBusServer extends GObject.GObject {
     connect(signal, handler, after = false) {
         const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta
-            ? [selfType, ...meta.params.map((m) => m.type)]
-            : [selfType];
+        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
         const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getObject(args[0]);
@@ -255,7 +249,7 @@ export class DBusServer extends GObject.GObject {
             if (!meta)
                 return handler(self, ...signalArgs);
             const wrapped = meta.params.map((m, i) => {
-                if (m.getCls && signalArgs[i] != null) {
+                if (m.type === "gobject" && signalArgs[i] != null) {
                     return getObject(signalArgs[i]);
                 }
                 return signalArgs[i];
@@ -273,4 +267,4 @@ export class DBusServer extends GObject.GObject {
         ], { type: "int", size: 64, unsigned: true });
     }
 }
-registerType(DBusServer);
+registerNativeClass(DBusServer);

package/dist/generated/gio/dbus-signal-info.d.ts

@@ -1,12 +1,13 @@
+import { NativeObject } from "../../native/base.js";
 import { DBusAnnotationInfo } from "./dbus-annotation-info.js";
 import { DBusArgInfo } from "./dbus-arg-info.js";
 export interface DBusSignalInfoInit {
     refCount?: number;
 }
 /** Information about a signal on a D-Bus interface. */
-export declare class DBusSignalInfo {
+export declare class DBusSignalInfo extends NativeObject {
     static readonly glibTypeName: string;
-    id: unknown;
+    static readonly objectType: "boxed";
     constructor(init?: DBusSignalInfoInit);
     protected createPtr(init: DBusSignalInfoInit): unknown;
     static fromPtr(ptr: unknown): DBusSignalInfo;

package/dist/generated/gio/dbus-signal-info.js

@@ -1,12 +1,14 @@
 import { alloc, read, write } from "@gtkx/native";
 import { call } from "../../batch.js";
-import { getBoxed } from "../../native.js";
-import { registerType } from "../../registry.js";
+import { getObject } from "../../native/object.js";
+import { NativeObject } from "../../native/base.js";
+import { registerNativeClass } from "../../registry.js";
 /** Information about a signal on a D-Bus interface. */
-export class DBusSignalInfo {
+export class DBusSignalInfo extends NativeObject {
     static glibTypeName = "GDBusSignalInfo";
-    id;
+    static objectType = "boxed";
     constructor(init = {}) {
+        super();
         this.id = this.createPtr(init);
     }
     createPtr(init) {
@@ -41,7 +43,7 @@ export class DBusSignalInfo {
             innerType: "GDBusSignalInfo",
             lib: "libgio-2.0.so.0",
         });
-        return getBoxed(ptr, DBusSignalInfo);
+        return getObject(ptr, DBusSignalInfo);
     }
     /**
      * If `info` is statically allocated, does nothing. Otherwise decreases
@@ -99,4 +101,4 @@ export class DBusSignalInfo {
         }, 24);
     }
 }
-registerType(DBusSignalInfo);
+registerNativeClass(DBusSignalInfo);