@gtkx/ffi 0.7.0 → 0.9.0

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

@@ -1,4 +1,8 @@
-import { call, NativeError, getObject, getBoxed, isInstantiating, setInstantiating, registerType, } from "@gtkx/ffi";
+import { call } from "../../batch.js";
+import { NativeError } from "../../native-error.js";
+import { getObject, getBoxed, isInstantiating, setInstantiating, } from "../../native.js";
+import { registerType } from "../../registry.js";
+import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 /**
  * The `GDBusConnection` type is used for D-Bus connections to remote
@@ -240,311 +244,6 @@ export class DBusConnection extends GObject.GObject {
         }
         return getObject(ptr);
     }
-    /**
-     * Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
-     * with the end represented by @stream.
-     *
-     * If `stream` is a #GSocketConnection, then the corresponding #GSocket
-     * will be put into non-blocking mode.
-     *
-     * The D-Bus connection will interact with `stream` from a worker thread.
-     * As a result, the caller should not interact with `stream` after this
-     * method has been called, except by calling g_object_unref() on it.
-     *
-     * If `observer` is not %NULL it may be used to control the
-     * authentication process.
-     *
-     * When the operation is finished, `callback` will be invoked. You can
-     * then call g_dbus_connection_new_finish() to get the result of the
-     * operation.
-     *
-     * This is an asynchronous failable constructor. See
-     * g_dbus_connection_new_sync() for the synchronous
-     * version.
-     * @param stream - a #GIOStream
-     * @param guid - the GUID to use if authenticating as a server or %NULL
-     * @param flags - flags describing how to make the connection
-     * @param observer - a #GDBusAuthObserver or %NULL
-     * @param cancellable - a #GCancellable or %NULL
-     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
-     * @param userData - the data to pass to @callback
-     */
-    static _new(stream, flags, guid, observer, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_connection_new", [
-            {
-                type: { type: "gobject", borrowed: true },
-                value: stream?.id ?? stream,
-            },
-            {
-                type: { type: "string" },
-                value: guid,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: observer?.id ?? observer,
-                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" });
-    }
-    /**
-     * Asynchronously connects and sets up a D-Bus client connection for
-     * exchanging D-Bus messages with an endpoint specified by `address` which must be in the
-     * D-Bus address format.
-     *
-     * This constructor can only be used to initiate client-side
-     * connections - use g_dbus_connection_new() if you need to act as the
-     * server. In particular, `flags` cannot contain the
-     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER,
-     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS or
-     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER flags.
-     *
-     * When the operation is finished, `callback` will be invoked. You can
-     * then call g_dbus_connection_new_for_address_finish() to get the result of
-     * the operation.
-     *
-     * If `observer` is not %NULL it may be used to control the
-     * authentication process.
-     *
-     * This is an asynchronous failable constructor. See
-     * g_dbus_connection_new_for_address_sync() for the synchronous
-     * version.
-     * @param address - a D-Bus address
-     * @param flags - flags describing how to make the connection
-     * @param observer - a #GDBusAuthObserver or %NULL
-     * @param cancellable - a #GCancellable or %NULL
-     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
-     * @param userData - the data to pass to @callback
-     */
-    static newForAddress(address, flags, observer, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_connection_new_for_address", [
-            {
-                type: { type: "string" },
-                value: address,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: observer?.id ?? observer,
-                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" });
-    }
-    /**
-     * Adds a message filter. Filters are handlers that are run on all
-     * incoming and outgoing messages, prior to standard dispatch. Filters
-     * are run in the order that they were added.  The same handler can be
-     * added as a filter more than once, in which case it will be run more
-     * than once.  Filters added during a filter callback won't be run on
-     * the message being processed. Filter functions are allowed to modify
-     * and even drop messages.
-     *
-     * Note that filters are run in a dedicated message handling thread so
-     * they can't block and, generally, can't do anything but signal a
-     * worker thread. Also note that filters are rarely needed - use API
-     * such as g_dbus_connection_send_message_with_reply(),
-     * g_dbus_connection_signal_subscribe() or g_dbus_connection_call() instead.
-     *
-     * If a filter consumes an incoming message the message is not
-     * dispatched anywhere else - not even the standard dispatch machinery
-     * (that API such as g_dbus_connection_signal_subscribe() and
-     * g_dbus_connection_send_message_with_reply() relies on) will see the
-     * message. Similarly, if a filter consumes an outgoing message, the
-     * message will not be sent to the other peer.
-     *
-     * If `user_data_free_func` is non-%NULL, it will be called (in the
-     * thread-default main context of the thread you are calling this
-     * method from) at some point after `user_data` is no longer
-     * needed. (It is not guaranteed to be called synchronously when the
-     * filter is removed, and may be called after `connection` has been
-     * destroyed.)
-     * @param filterFunction - a filter function
-     * @param userData - user data to pass to @filter_function
-     * @param userDataFreeFunc - function to free `user_data` with when filter
-     */
-    addFilter(filterFunction, userDataFreeFunc, userData) {
-        return call("libgio-2.0.so.0", "g_dbus_connection_add_filter", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "callback" },
-                value: filterFunction,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: userDataFreeFunc,
-            },
-        ], { type: "int", size: 32, unsigned: true });
-    }
-    /**
-     * Asynchronously invokes the `method_name` method on the
-     * `interface_name` D-Bus interface on the remote object at
-     * `object_path` owned by @bus_name.
-     *
-     * If `connection` 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 `reply_type` is non-%NULL then the reply will be checked for having this type and an
-     * error will be raised if it does not match.  Said another way, if you give a `reply_type` then any non-%NULL return value will be of this type. Unless it’s
-     * %G_VARIANT_TYPE_UNIT, the `reply_type` will be a tuple containing one or more
-     * values.
-     *
-     * If the `parameters` #GVariant is floating, it is consumed. This allows
-     * convenient 'inline' use of g_variant_new(), e.g.:
-     * |[<!-- language="C" -->
-     * g_dbus_connection_call (connection,
-     * "org.freedesktop.StringThings",
-     * "/org/freedesktop/StringThings",
-     * "org.freedesktop.StringThings",
-     * "TwoStrings",
-     * g_variant_new ("(ss)",
-     * "Thing One",
-     * "Thing Two"),
-     * NULL,
-     * G_DBUS_CALL_FLAGS_NONE,
-     * -1,
-     * NULL,
-     * (GAsyncReadyCallback) two_strings_done,
-     * NULL);
-     * ]|
-     *
-     * 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_connection_call_finish() to get the result of the operation.
-     * See g_dbus_connection_call_sync() for the synchronous version of this
-     * function.
-     *
-     * 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 busName - a unique or well-known bus name or %NULL if
-     * @param objectPath - path of remote object
-     * @param interfaceName - D-Bus interface to invoke method on
-     * @param methodName - the name of the method to invoke
-     * @param parameters - a #GVariant tuple with parameters for the method
-     * @param replyType - the expected type of the reply (which will be a
-     * @param flags - flags from the #GDBusCallFlags enumeration
-     * @param timeoutMsec - the timeout in milliseconds, -1 to use the default
-     * @param cancellable - a #GCancellable or %NULL
-     * @param callback - a #GAsyncReadyCallback to call when the request
-     * @param userData - the data to pass to @callback
-     */
-    call(objectPath, interfaceName, methodName, flags, timeoutMsec, busName, parameters, replyType, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_connection_call", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: busName,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-            },
-            {
-                type: { type: "string" },
-                value: interfaceName,
-            },
-            {
-                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: "boxed",
-                    borrowed: true,
-                    innerType: "GVariantType",
-                    lib: "libgio-2.0.so.0",
-                },
-                value: replyType?.id ?? replyType,
-                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_connection_call().
      * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call()
@@ -580,7 +279,7 @@ export class DBusConnection extends GObject.GObject {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getBoxed(ptr, "GVariant");
+        return getBoxed(ptr, GLib.Variant);
     }
     /**
      * Synchronously invokes the `method_name` method on the
@@ -705,109 +404,7 @@ export class DBusConnection extends GObject.GObject {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        return getBoxed(ptr, "GVariant");
-    }
-    /**
-     * Like g_dbus_connection_call() but also takes a #GUnixFDList object.
-     *
-     * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
-     * values in the body of the message. For example, if a message contains
-     * two file descriptors, `fd_list` would have length 2, and
-     * `g_variant_new_handle (0)` and `g_variant_new_handle (1)` would appear
-     * somewhere in the body of the message (not necessarily in that order!)
-     * to represent the file descriptors at indexes 0 and 1 respectively.
-     *
-     * When designing D-Bus APIs that are intended to be interoperable,
-     * please note that non-GDBus implementations of D-Bus can usually only
-     * access file descriptors if they are referenced in this way by a
-     * value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
-     *
-     * This method is only available on UNIX.
-     * @param busName - a unique or well-known bus name or %NULL if
-     * @param objectPath - path of remote object
-     * @param interfaceName - D-Bus interface to invoke method on
-     * @param methodName - the name of the method to invoke
-     * @param parameters - a #GVariant tuple with parameters for the method
-     * @param replyType - the expected type of the reply, or %NULL
-     * @param flags - flags from the #GDBusCallFlags enumeration
-     * @param timeoutMsec - the timeout in milliseconds, -1 to use the default
-     * @param fdList - a #GUnixFDList or %NULL
-     * @param cancellable - a #GCancellable or %NULL
-     * @param callback - a #GAsyncReadyCallback to call when the request is
-     * @param userData - The data to pass to @callback.
-     */
-    callWithUnixFdList(objectPath, interfaceName, methodName, flags, timeoutMsec, busName, parameters, replyType, fdList, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_connection_call_with_unix_fd_list", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: busName,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-            },
-            {
-                type: { type: "string" },
-                value: interfaceName,
-            },
-            {
-                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: "boxed",
-                    borrowed: true,
-                    innerType: "GVariantType",
-                    lib: "libgio-2.0.so.0",
-                },
-                value: replyType?.id ?? replyType,
-                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 getBoxed(ptr, GLib.Variant);
     }
     /**
      * Finishes an operation started with g_dbus_connection_call_with_unix_fd_list().
@@ -863,7 +460,7 @@ export class DBusConnection extends GObject.GObject {
         }
         if (outFdList)
             outFdList.value = getObject(outFdList.value);
-        return getBoxed(ptr, "GVariant");
+        return getBoxed(ptr, GLib.Variant);
     }
     /**
      * Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
@@ -972,59 +569,7 @@ export class DBusConnection extends GObject.GObject {
         }
         if (outFdList)
             outFdList.value = getObject(outFdList.value);
-        return getBoxed(ptr, "GVariant");
-    }
-    /**
-     * Closes @connection. Note that this never causes the process to
-     * exit (this might only happen if the other end of a shared message
-     * bus connection disconnects, see #GDBusConnection:exit-on-close).
-     *
-     * Once the connection is closed, operations such as sending a message
-     * will return with the error %G_IO_ERROR_CLOSED. Closing a connection
-     * will not automatically flush the connection so queued messages may
-     * be lost. Use g_dbus_connection_flush() if you need such guarantees.
-     *
-     * If `connection` is already closed, this method fails with
-     * %G_IO_ERROR_CLOSED.
-     *
-     * When `connection` has been closed, the #GDBusConnection::closed
-     * signal is emitted in the thread-default main context
-     * (see [method@GLib.MainContext.push_thread_default])
-     * of the thread that `connection` was constructed in.
-     *
-     * 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_connection_close_finish() to get the result of the
-     * operation. See g_dbus_connection_close_sync() for the synchronous
-     * version.
-     * @param cancellable - a #GCancellable or %NULL
-     * @param callback - a #GAsyncReadyCallback to call when the request is
-     * @param userData - The data to pass to @callback
-     */
-    close(cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_connection_close", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                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 getBoxed(ptr, GLib.Variant);
     }
     /**
      * Finishes an operation started with g_dbus_connection_close().
@@ -1268,48 +813,6 @@ export class DBusConnection extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * Asynchronously flushes @connection, that is, writes all queued
-     * outgoing messages to the transport and then flushes the transport
-     * (using g_output_stream_flush_async()). This is useful in programs
-     * that want to emit a D-Bus signal and then exit immediately. Without
-     * flushing the connection, there is no guarantee that the message has
-     * been sent to the networking buffers in the OS kernel.
-     *
-     * 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_connection_flush_finish() to get the result of the
-     * operation. See g_dbus_connection_flush_sync() for the synchronous
-     * version.
-     * @param cancellable - a #GCancellable or %NULL
-     * @param callback - a #GAsyncReadyCallback to call when the
-     * @param userData - The data to pass to @callback
-     */
-    flush(cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_connection_flush", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                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_connection_flush().
      * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
@@ -1942,87 +1445,6 @@ export class DBusConnection extends GObject.GObject {
         }
         return result;
     }
-    /**
-     * Asynchronously sends `message` to the peer represented by @connection.
-     *
-     * Unless `flags` contain the
-     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
-     * will be assigned by `connection` and set on `message` via
-     * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
-     * serial number used will be written to this location prior to
-     * submitting the message to the underlying transport. While it has a `volatile`
-     * qualifier, this is a historical artifact and the argument passed to it should
-     * not be `volatile`.
-     *
-     * If `connection` 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 `message` is not well-formed,
-     * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
-     *
-     * 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_connection_send_message_with_reply_finish() to get the result of the operation.
-     * See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
-     *
-     * Note that `message` must be unlocked, unless `flags` contain the
-     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
-     *
-     * See this [server][class@Gio.DBusConnection#an-example-d-bus-server]
-     * and [client][class@Gio.DBusConnection#an-example-for-file-descriptor-passing]
-     * for an example of how to use this low-level API to send and receive
-     * UNIX file descriptors.
-     * @param message - a #GDBusMessage
-     * @param flags - flags affecting how the message is sent
-     * @param timeoutMsec - the timeout in milliseconds, -1 to use the default
-     * @param outSerial - return location for serial number assigned
-     * @param cancellable - a #GCancellable or %NULL
-     * @param callback - a #GAsyncReadyCallback to call when the request
-     * @param userData - The data to pass to @callback
-     */
-    sendMessageWithReply(message, flags, timeoutMsec, outSerial, cancellable, callback, userData) {
-        call("libgio-2.0.so.0", "g_dbus_connection_send_message_with_reply", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: message?.id ?? message,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: timeoutMsec,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: { type: "int", size: 32, unsigned: true },
-                },
-                value: outSerial,
-                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" });
-    }
     /**
      * Finishes an operation started with g_dbus_connection_send_message_with_reply().
      *
@@ -2176,116 +1598,6 @@ export class DBusConnection extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
-    /**
-     * Subscribes to signals on `connection` and invokes `callback` whenever
-     * the signal is received. Note that `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.
-     *
-     * If `connection` is not a message bus connection, `sender` must be
-     * %NULL.
-     *
-     * If `sender` is a well-known name note that `callback` is invoked with
-     * the unique name for the owner of @sender, not the well-known name
-     * as one would expect. This is because the message bus rewrites the
-     * name. As such, to avoid certain race conditions, users should be
-     * tracking the name owner of the well-known name and use that when
-     * processing the received signal.
-     *
-     * If one of %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE or
-     * %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH are given, `arg0` is
-     * interpreted as part of a namespace or path.  The first argument
-     * of a signal is matched against that part as specified by D-Bus.
-     *
-     * If `user_data_free_func` is non-%NULL, it will be called (in the
-     * thread-default main context of the thread you are calling this
-     * method from) at some point after `user_data` is no longer
-     * needed. (It is not guaranteed to be called synchronously when the
-     * signal is unsubscribed from, and may be called after `connection` has been destroyed.)
-     *
-     * As `callback` is potentially invoked in a different thread from where it’s
-     * emitted, it’s possible for this to happen after
-     * g_dbus_connection_signal_unsubscribe() has been called in another thread.
-     * Due to this, `user_data` should have a strong reference which is freed with
-     * @user_data_free_func, rather than pointing to data whose lifecycle is tied
-     * to the signal subscription. For example, if a #GObject is used to store the
-     * subscription ID from g_dbus_connection_signal_subscribe(), a strong reference
-     * to that #GObject must be passed to @user_data, and g_object_unref() passed to
-     * @user_data_free_func. You are responsible for breaking the resulting
-     * reference count cycle by explicitly unsubscribing from the signal when
-     * dropping the last external reference to the #GObject. Alternatively, a weak
-     * reference may be used.
-     *
-     * It is guaranteed that if you unsubscribe from a signal using
-     * g_dbus_connection_signal_unsubscribe() from the same thread which made the
-     * corresponding g_dbus_connection_signal_subscribe() call, `callback` will not
-     * be invoked after g_dbus_connection_signal_unsubscribe() returns.
-     *
-     * The returned subscription identifier is an opaque value which is guaranteed
-     * to never be zero.
-     *
-     * This function can never fail.
-     * @param sender - sender name to match on (unique or well-known name)
-     * @param interfaceName - D-Bus interface name to match on or %NULL to
-     * @param member - D-Bus signal name to match on or %NULL to match on
-     * @param objectPath - object path to match on or %NULL to match on
-     * @param arg0 - contents of first string argument to match on or %NULL
-     * @param flags - #GDBusSignalFlags describing how arg0 is used in subscribing to the
-     * @param callback - callback to invoke when there is a signal matching the requested data
-     * @param userData - user data to pass to @callback
-     * @param userDataFreeFunc - function to free `user_data` with when
-     */
-    signalSubscribe(flags, callback, sender, interfaceName, member, objectPath, arg0, userData, userDataFreeFunc) {
-        return call("libgio-2.0.so.0", "g_dbus_connection_signal_subscribe", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string" },
-                value: sender,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: interfaceName,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: member,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: objectPath,
-                optional: true,
-            },
-            {
-                type: { type: "string" },
-                value: arg0,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: flags,
-            },
-            {
-                type: { type: "callback" },
-                value: callback,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: userData,
-                optional: true,
-            },
-            {
-                type: { type: "callback", trampoline: "destroy" },
-                value: userDataFreeFunc,
-                optional: true,
-            },
-        ], { type: "int", size: 32, unsigned: true });
-    }
     /**
      * Unsubscribes from signals.
      *
@@ -2401,75 +1713,6 @@ export class DBusConnection extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
-    /**
-     * 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().