@gtkx/ffi 0.10.5 → 0.11.1

package/dist/generated/gio/d-bus-connection.js

@@ -0,0 +1,2934 @@
+import { call } from "../../batch.js";
+import { NativeError } from "../../native/error.js";
+import { getNativeObject } from "../../native/object.js";
+import { isInstantiating, setInstantiating } from "../../native/base.js";
+import { registerNativeClass } from "../../registry.js";
+import { AsyncResult } from "./async-result.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
+ * peers such as a message buses.
+ *
+ * It is a low-level API that offers a lot of flexibility. For instance,
+ * it lets you establish a connection over any transport that can by represented
+ * as a {@link Gio.IOStream}.
+ *
+ * This class is rarely used directly in D-Bus clients. If you are writing
+ * a D-Bus client, it is often easier to use the {@link Gio.bus_own_name},
+ * {@link Gio.bus_watch_name} or {@link Gio.DBusProxy.new_for_bus} APIs.
+ *
+ * As an exception to the usual GLib rule that a particular object must not
+ * be used by two threads at the same time, `GDBusConnection`s methods may be
+ * called from any thread. This is so that {@link Gio.bus_get} and
+ * {@link Gio.bus_get_sync} can safely return the same `GDBusConnection` when
+ * called from any thread.
+ *
+ * Most of the ways to obtain a `GDBusConnection` automatically initialize it
+ * (i.e. connect to D-Bus): for instance, {@link Gio.DBusConnection.new} and
+ * {@link Gio.bus_get}, and the synchronous versions of those methods, give you
+ * an initialized connection. Language bindings for GIO should use
+ * {@link Gio.Initable.new} or {@link Gio.AsyncInitable.new_async}, which also
+ * initialize the connection.
+ *
+ * If you construct an uninitialized `GDBusConnection`, such as via
+ * {@link GObject.Object.new}, you must initialize it via {@link Gio.Initable.init} or
+ * {@link Gio.AsyncInitable.init_async} before using its methods or properties.
+ * Calling methods or accessing properties on a `GDBusConnection` that has not
+ * completed initialization successfully is considered to be invalid, and leads
+ * to undefined behaviour. In particular, if initialization fails with a
+ * `GError`, the only valid thing you can do with that `GDBusConnection` is to
+ * free it with {@link GObject.Object.unref}.
+ *
+ * ## An example D-Bus server
+ *
+ * Here is an example for a D-Bus server:
+ * [gdbus-example-server.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-server.c)
+ *
+ * ## An example for exporting a subtree
+ *
+ * Here is an example for exporting a subtree:
+ * [gdbus-example-subtree.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-subtree.c)
+ *
+ * ## An example for file descriptor passing
+ *
+ * Here is an example for passing UNIX file descriptors:
+ * [gdbus-unix-fd-client.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-unix-fd-client.c)
+ *
+ * ## An example for exporting a GObject
+ *
+ * Here is an example for exporting a #GObject:
+ * [gdbus-example-export.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-export.c)
+ */
+export class DBusConnection extends GObject.GObject {
+    static glibTypeName = "GDBusConnection";
+    static objectType = "gobject";
+    /** Finishes an operation started with g_dbus_connection_new(). */
+    constructor(res) {
+        if (!isInstantiating) {
+            setInstantiating(true);
+            // @ts-ignore
+            super();
+            setInstantiating(false);
+            this.id = call("libgio-2.0.so.0", "g_dbus_connection_new_finish", [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: res.id,
+                    optional: false,
+                },
+            ], { type: "gobject", ownership: "full" });
+        }
+        else {
+            // @ts-ignore
+            super();
+        }
+    }
+    /** Finishes an operation started with g_dbus_connection_new_for_address(). */
+    static newForAddressFinish(res) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_new_for_address_finish", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: res.id,
+                optional: false,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+                optional: false,
+            },
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return getNativeObject(ptr);
+    }
+    /**
+     * Synchronously 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_sync() 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.
+     *
+     * This is a synchronous failable constructor. See
+     * g_dbus_connection_new_for_address() for the asynchronous version.
+     *
+     * If `observer` is not %NULL it may be used to control the
+     * authentication process.
+     */
+    static newForAddressSync(address, flags, observer, cancellable) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_new_for_address_sync", [
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: address,
+                optional: false,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: flags,
+                optional: false,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: observer?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+                optional: false,
+            },
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return getNativeObject(ptr);
+    }
+    /**
+     * Synchronously 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.
+     *
+     * This is a synchronous failable constructor. See
+     * g_dbus_connection_new() for the asynchronous version.
+     */
+    static newSync(stream, flags, guid, observer, cancellable) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_new_sync", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: stream.id,
+                optional: false,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: guid,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: flags,
+                optional: false,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: observer?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+                optional: false,
+            },
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return getNativeObject(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.
+     */
+    static new_(stream, flags, guid, observer, cancellable, callback) {
+        const wrappedCallback = callback
+            ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+            : null;
+        call("libgio-2.0.so.0", "g_dbus_connection_new", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: stream.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: guid,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: flags,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: observer?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "callback",
+                    trampoline: "asyncReady",
+                    argTypes: [
+                        {
+                            type: "gobject",
+                            ownership: "none",
+                        },
+                        {
+                            type: "gobject",
+                            ownership: "none",
+                        },
+                    ],
+                },
+                value: wrappedCallback,
+                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.
+     */
+    static newForAddress(address, flags, observer, cancellable, callback) {
+        const wrappedCallback = callback
+            ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+            : null;
+        call("libgio-2.0.so.0", "g_dbus_connection_new_for_address", [
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: address,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: flags,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: observer?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "callback",
+                    trampoline: "asyncReady",
+                    argTypes: [
+                        {
+                            type: "gobject",
+                            ownership: "none",
+                        },
+                        {
+                            type: "gobject",
+                            ownership: "none",
+                        },
+                    ],
+                },
+                value: wrappedCallback,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * Synchronously 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.
+     *
+     * 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_sync (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,
+     *                               &error);
+     * ]|
+     *
+     * The calling thread is blocked until a reply is received. See
+     * g_dbus_connection_call() for the asynchronous version of
+     * this method.
+     */
+    callSync(objectPath, interfaceName, methodName, flags, timeoutMsec, busName, parameters, replyType, cancellable) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_call_sync", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: busName,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: interfaceName,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: methodName,
+            },
+            {
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
+                value: parameters,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    getTypeFn: "g_variant_type_get_gtype",
+                },
+                value: replyType?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: flags,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
+                value: timeoutMsec,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return getNativeObject(ptr, GLib.Variant);
+    }
+    /**
+     * Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
+     * See g_dbus_connection_call_with_unix_fd_list() and
+     * g_dbus_connection_call_with_unix_fd_list_finish() for more details.
+     *
+     * This method is only available on UNIX.
+     */
+    callWithUnixFdListSync(objectPath, interfaceName, methodName, flags, timeoutMsec, busName, parameters, replyType, fdList, outFdList, cancellable) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_call_with_unix_fd_list_sync", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: busName,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: interfaceName,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: methodName,
+            },
+            {
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
+                value: parameters,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GVariantType",
+                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                    getTypeFn: "g_variant_type_get_gtype",
+                },
+                value: replyType?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: flags,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
+                value: timeoutMsec,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: fdList?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "gobject",
+                        ownership: "full",
+                    },
+                },
+                value: outFdList,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "gvariant",
+            ownership: "full",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        if (outFdList)
+            outFdList.value = getNativeObject(outFdList.value);
+        return getNativeObject(ptr, GLib.Variant);
+    }
+    /**
+     * Synchronously closes `connection`. The calling thread is blocked
+     * until this is done. See g_dbus_connection_close() for the
+     * asynchronous version of this method and more details about what it
+     * does.
+     */
+    closeSync(cancellable) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_close_sync", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "boolean",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Emits a signal.
+     *
+     * If the parameters GVariant is floating, it is consumed.
+     *
+     * This can only fail if `parameters` is not compatible with the D-Bus protocol
+     * (%G_IO_ERROR_INVALID_ARGUMENT), or if `connection` has been closed
+     * (%G_IO_ERROR_CLOSED).
+     */
+    emitSignal(objectPath, interfaceName, signalName, destinationBusName, parameters) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_emit_signal", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: destinationBusName,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: interfaceName,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: signalName,
+            },
+            {
+                type: {
+                    type: "gvariant",
+                    ownership: "none",
+                },
+                value: parameters,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "boolean",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Exports `action_group` on `connection` at `object_path`.
+     *
+     * The implemented D-Bus API should be considered private.  It is
+     * subject to change in the future.
+     *
+     * A given object path can only have one action group exported on it.
+     * If this constraint is violated, the export will fail and 0 will be
+     * returned (with `error` set accordingly).
+     *
+     * You can unexport the action group using
+     * {@link Gio.DBusConnection.unexport_action_group} with the return value of
+     * this function.
+     *
+     * The thread default main context is taken at the time of this call.
+     * All incoming action activations and state change requests are
+     * reported from this context.  Any changes on the action group that
+     * cause it to emit signals must also come from this same context.
+     * Since incoming action activations and state change requests are
+     * rather likely to cause changes on the action group, this effectively
+     * limits a given action group to being exported from only one main
+     * context.
+     */
+    exportActionGroup(objectPath, actionGroup) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_export_action_group", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: actionGroup.id,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Exports `menu` on `connection` at `object_path`.
+     *
+     * The implemented D-Bus API should be considered private.
+     * It is subject to change in the future.
+     *
+     * An object path can only have one menu model exported on it. If this
+     * constraint is violated, the export will fail and 0 will be
+     * returned (with `error` set accordingly).
+     *
+     * Exporting menus with sections containing more than
+     * %G_MENU_EXPORTER_MAX_SECTION_SIZE items is not supported and results in
+     * undefined behavior.
+     *
+     * You can unexport the menu model using
+     * g_dbus_connection_unexport_menu_model() with the return value of
+     * this function.
+     */
+    exportMenuModel(objectPath, menu) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_export_menu_model", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: menu.id,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Synchronously flushes `connection`. The calling thread is blocked
+     * until this is done. See g_dbus_connection_flush() for the
+     * asynchronous version of this method and more details about what it
+     * does.
+     */
+    flushSync(cancellable) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_flush_sync", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "boolean",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /** Gets the capabilities negotiated with the remote peer */
+    getCapabilities() {
+        return call("libgio-2.0.so.0", "g_dbus_connection_get_capabilities", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+    }
+    /**
+     * Gets whether the process is terminated when `connection` is
+     * closed by the remote peer. See
+     * #GDBusConnection:exit-on-close for more details.
+     */
+    getExitOnClose() {
+        return call("libgio-2.0.so.0", "g_dbus_connection_get_exit_on_close", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Gets the flags used to construct this connection */
+    getFlags() {
+        return call("libgio-2.0.so.0", "g_dbus_connection_get_flags", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+    }
+    /**
+     * The GUID of the peer performing the role of server when
+     * authenticating. See #GDBusConnection:guid for more details.
+     */
+    getGuid() {
+        return call("libgio-2.0.so.0", "g_dbus_connection_get_guid", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "string",
+            ownership: "none",
+        });
+    }
+    /**
+     * Retrieves the last serial number assigned to a #GDBusMessage on
+     * the current thread. This includes messages sent via both low-level
+     * API such as g_dbus_connection_send_message() as well as
+     * high-level API such as g_dbus_connection_emit_signal(),
+     * g_dbus_connection_call() or g_dbus_proxy_call().
+     */
+    getLastSerial() {
+        return call("libgio-2.0.so.0", "g_dbus_connection_get_last_serial", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+    }
+    /**
+     * Gets the credentials of the authenticated peer. This will always
+     * return %NULL unless `connection` acted as a server
+     * (e.g. %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER was passed)
+     * when set up and the client passed credentials as part of the
+     * authentication process.
+     *
+     * In a message bus setup, the message bus is always the server and
+     * each application is a client. So this method will always return
+     * %NULL for message bus clients.
+     */
+    getPeerCredentials() {
+        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_get_peer_credentials", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
+        if (ptr === null)
+            return null;
+        return getNativeObject(ptr);
+    }
+    /**
+     * Gets the underlying stream used for IO.
+     *
+     * While the #GDBusConnection is active, it will interact with this
+     * stream from a worker thread, so it is not safe to interact with
+     * the stream directly.
+     */
+    getStream() {
+        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_get_stream", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "gobject",
+            ownership: "none",
+        });
+        return getNativeObject(ptr);
+    }
+    /**
+     * Gets the unique name of `connection` as assigned by the message
+     * bus. This can also be used to figure out if `connection` is a
+     * message bus connection.
+     */
+    getUniqueName() {
+        return call("libgio-2.0.so.0", "g_dbus_connection_get_unique_name", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "string",
+            ownership: "none",
+        });
+    }
+    /** Gets whether `connection` is closed. */
+    isClosed() {
+        return call("libgio-2.0.so.0", "g_dbus_connection_is_closed", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * Registers callbacks for exported objects at `object_path` with the
+     * D-Bus interface that is described in `interface_info`.
+     *
+     * Calls to functions in `vtable` (and `user_data_free_func`) will happen
+     * in the thread-default main context
+     * (see {@link GLib.MainContext.push_thread_default})
+     * of the thread you are calling this method from.
+     *
+     * Note that all #GVariant values passed to functions in `vtable` will match
+     * the signature given in `interface_info` - if a remote caller passes
+     * incorrect values, the `org.freedesktop.DBus.Error.InvalidArgs`
+     * is returned to the remote caller.
+     *
+     * Additionally, if the remote caller attempts to invoke methods or
+     * access properties not mentioned in `interface_info` the
+     * `org.freedesktop.DBus.Error.UnknownMethod` resp.
+     * `org.freedesktop.DBus.Error.InvalidArgs` errors
+     * are returned to the caller.
+     *
+     * It is considered a programming error if the
+     * #GDBusInterfaceGetPropertyFunc function in `vtable` returns a
+     * #GVariant of incorrect type.
+     *
+     * If an existing callback is already registered at `object_path` and
+     * `interface_name`, then `error` is set to %G_IO_ERROR_EXISTS.
+     *
+     * GDBus automatically implements the standard D-Bus interfaces
+     * org.freedesktop.DBus.Properties, org.freedesktop.DBus.Introspectable
+     * and org.freedesktop.Peer, so you don't have to implement those for the
+     * objects you export. You can implement org.freedesktop.DBus.Properties
+     * yourself, e.g. to handle getting and setting of properties asynchronously.
+     *
+     * Note that the reference count on `interface_info` will be
+     * incremented by 1 (unless allocated statically, e.g. if the
+     * reference count is -1, see g_dbus_interface_info_ref()) for as long
+     * as the object is exported. Also note that `vtable` will be copied.
+     *
+     * See this [server]{@link Gio.DBusConnection#an-example-d-bus-server}
+     * for an example of how to use this method.
+     */
+    registerObject(objectPath, interfaceInfo, userDataFreeFunc, vtable, userData) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_register_object", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GDBusInterfaceInfo",
+                    lib: "libgio-2.0.so.0",
+                    getTypeFn: "g_dbus_interface_info_get_type",
+                },
+                value: interfaceInfo.id,
+            },
+            {
+                type: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "DBusInterfaceVTable",
+                },
+                value: vtable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: userData,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "callback",
+                    trampoline: "destroy",
+                },
+                value: userDataFreeFunc,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Version of g_dbus_connection_register_object() using closures instead of a
+     * #GDBusInterfaceVTable for easier binding in other languages.
+     *
+     * Note that the reference counting semantics of the function wrapped by
+     * `method_call_closure` are the same as those of
+     * {@link Gio.DBusInterfaceMethodCallFunc}: ownership of a reference to the
+     * {@link Gio.DBusMethodInvocation} is transferred to the function.
+     */
+    registerObjectWithClosures(objectPath, interfaceInfo, methodCallClosure, getPropertyClosure, setPropertyClosure) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_register_object_with_closures", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GDBusInterfaceInfo",
+                    lib: "libgio-2.0.so.0",
+                    getTypeFn: "g_dbus_interface_info_get_type",
+                },
+                value: interfaceInfo.id,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GClosure",
+                    lib: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: methodCallClosure?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GClosure",
+                    lib: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: getPropertyClosure?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GClosure",
+                    lib: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: setPropertyClosure?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Version of {@link Gio.DBusConnection.register_object} using closures instead
+     * of a {@link Gio.DBusInterfaceVTable} for easier binding in other languages.
+     *
+     * In contrast to {@link Gio.DBusConnection.register_object} and
+     * {@link Gio.DBusConnection.register_object_with_closures}, the reference
+     * counting semantics of the function wrapped by `method_call_closure` are *not*
+     * the same as those of {@link Gio.DBusInterfaceMethodCallFunc}. Ownership of
+     * a reference to the {@link Gio.DBusMethodInvocation} is *not* transferred to
+     * the function. Bindings must ensure that they add a reference to the
+     * {@link Gio.DBusMethodInvocation} before calling any
+     * `g_dbus_method_invocation_return_*()` methods on it. This should be automatic
+     * as a result of the introspection annotations on those methods.
+     */
+    registerObjectWithClosures2(objectPath, interfaceInfo, methodCallClosure, getPropertyClosure, setPropertyClosure) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_register_object_with_closures2", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GDBusInterfaceInfo",
+                    lib: "libgio-2.0.so.0",
+                    getTypeFn: "g_dbus_interface_info_get_type",
+                },
+                value: interfaceInfo.id,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GClosure",
+                    lib: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: methodCallClosure?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GClosure",
+                    lib: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: getPropertyClosure?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "boxed",
+                    ownership: "none",
+                    innerType: "GClosure",
+                    lib: "libgobject-2.0.so.0",
+                    getTypeFn: "g_closure_get_type",
+                },
+                value: setPropertyClosure?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Registers a whole subtree of dynamic objects.
+     *
+     * The `enumerate` and `introspection` functions in `vtable` are used to
+     * convey, to remote callers, what nodes exist in the subtree rooted
+     * by `object_path`.
+     *
+     * When handling remote calls into any node in the subtree, first the
+     * `enumerate` function is used to check if the node exists. If the node exists
+     * or the %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set
+     * the `introspection` function is used to check if the node supports the
+     * requested method. If so, the `dispatch` function is used to determine
+     * where to dispatch the call. The collected #GDBusInterfaceVTable and
+     * #gpointer will be used to call into the interface vtable for processing
+     * the request.
+     *
+     * All calls into user-provided code will be invoked in the thread-default
+     * main context (see {@link GLib.MainContext.push_thread_default})
+     * of the thread you are calling this method from.
+     *
+     * If an existing subtree is already registered at `object_path` or
+     * then `error` is set to %G_IO_ERROR_EXISTS.
+     *
+     * Note that it is valid to register regular objects (using
+     * g_dbus_connection_register_object()) in a subtree registered with
+     * g_dbus_connection_register_subtree() - if so, the subtree handler
+     * is tried as the last resort. One way to think about a subtree
+     * handler is to consider it a fallback handler for object paths not
+     * registered via g_dbus_connection_register_object() or other bindings.
+     *
+     * Note that `vtable` will be copied so you cannot change it after
+     * registration.
+     *
+     * See this [server]{@link Gio.DBusConnection#an-example-for-exporting-a-subtree}
+     * for an example of how to use this method.
+     */
+    registerSubtree(objectPath, vtable, flags, userDataFreeFunc, userData) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_register_subtree", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "string",
+                    ownership: "none",
+                },
+                value: objectPath,
+            },
+            {
+                type: {
+                    type: "struct",
+                    ownership: "none",
+                    innerType: "DBusSubtreeVTable",
+                },
+                value: vtable.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: flags,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 64,
+                    unsigned: true,
+                },
+                value: userData,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "callback",
+                    trampoline: "destroy",
+                },
+                value: userDataFreeFunc,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "int",
+            size: 32,
+            unsigned: true,
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Removes a filter.
+     *
+     * Note that since filters run in a different thread, there is a race
+     * condition where it is possible that the filter will be running even
+     * after calling g_dbus_connection_remove_filter(), so you cannot just
+     * free data that the filter might be using. Instead, you should pass
+     * a #GDestroyNotify to g_dbus_connection_add_filter(), which will be
+     * called when it is guaranteed that the data is no longer needed.
+     */
+    removeFilter(filterId) {
+        call("libgio-2.0.so.0", "g_dbus_connection_remove_filter", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: filterId,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * 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 `message` is not well-formed,
+     * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
+     *
+     * See this [server]{@link Gio.DBusConnection#an-example-d-bus-server}
+     * and [client]{@link 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.
+     *
+     * Note that `message` must be unlocked, unless `flags` contain the
+     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+     */
+    sendMessage(message, flags, outSerial) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_dbus_connection_send_message", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: message.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: flags,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                },
+                value: outSerial,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "boolean",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Synchronously sends `message` to the peer represented by `connection`
+     * and blocks the calling thread until a reply is received or the
+     * timeout is reached. See g_dbus_connection_send_message_with_reply()
+     * for the asynchronous version of this method.
+     *
+     * 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.
+     *
+     * Note that `error` is only set if a local in-process error
+     * occurred. That is to say that the returned #GDBusMessage object may
+     * be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
+     * g_dbus_message_to_gerror() to transcode this to a #GError.
+     *
+     * See this [server]{@link Gio.DBusConnection#an-example-d-bus-server}
+     * and [client]{@link 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.
+     *
+     * Note that `message` must be unlocked, unless `flags` contain the
+     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+     */
+    sendMessageWithReplySync(message, flags, timeoutMsec, outSerial, cancellable) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_send_message_with_reply_sync", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: message.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                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",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return getNativeObject(ptr);
+    }
+    /**
+     * Sets whether the process should be terminated when `connection` is
+     * closed by the remote peer. See #GDBusConnection:exit-on-close for
+     * more details.
+     *
+     * Note that this function should be used with care. Most modern UNIX
+     * desktops tie the notion of a user session with the session bus, and expect
+     * all of a user's applications to quit when their bus connection goes away.
+     * If you are setting `exit_on_close` to %FALSE for the shared session
+     * bus connection, you should make sure that your application exits
+     * when the user session ends.
+     */
+    setExitOnClose(exitOnClose) {
+        call("libgio-2.0.so.0", "g_dbus_connection_set_exit_on_close", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "boolean",
+                },
+                value: exitOnClose,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * Unsubscribes from signals.
+     *
+     * Note that there may still be D-Bus traffic to process (relating to this
+     * signal subscription) in the current thread-default #GMainContext after this
+     * function has returned. You should continue to iterate the #GMainContext
+     * until the #GDestroyNotify function passed to
+     * g_dbus_connection_signal_subscribe() is called, in order to avoid memory
+     * leaks through callbacks queued on the #GMainContext after it’s stopped being
+     * iterated.
+     * Alternatively, any idle source with a priority lower than %G_PRIORITY_DEFAULT
+     * that was scheduled after unsubscription, also indicates that all resources
+     * of this subscription are released.
+     */
+    signalUnsubscribe(subscriptionId) {
+        call("libgio-2.0.so.0", "g_dbus_connection_signal_unsubscribe", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: subscriptionId,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * If `connection` was created with
+     * %G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method
+     * starts processing messages. Does nothing on if `connection` wasn't
+     * created with this flag or if the method has already been called.
+     */
+    startMessageProcessing() {
+        call("libgio-2.0.so.0", "g_dbus_connection_start_message_processing", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * Reverses the effect of a previous call to
+     * {@link Gio.DBusConnection.export_action_group}.
+     *
+     * It is an error to call this function with an ID that wasn’t returned from
+     * {@link Gio.DBusConnection.export_action_group} or to call it with the same
+     * ID more than once.
+     */
+    unexportActionGroup(exportId) {
+        call("libgio-2.0.so.0", "g_dbus_connection_unexport_action_group", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: exportId,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * Reverses the effect of a previous call to
+     * g_dbus_connection_export_menu_model().
+     *
+     * It is an error to call this function with an ID that wasn't returned
+     * from g_dbus_connection_export_menu_model() or to call it with the
+     * same ID more than once.
+     */
+    unexportMenuModel(exportId) {
+        call("libgio-2.0.so.0", "g_dbus_connection_unexport_menu_model", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: exportId,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /** Unregisters an object. */
+    unregisterObject(registrationId) {
+        return call("libgio-2.0.so.0", "g_dbus_connection_unregister_object", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: registrationId,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /** Unregisters a subtree. */
+    unregisterSubtree(registrationId) {
+        return call("libgio-2.0.so.0", "g_dbus_connection_unregister_subtree", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: true,
+                },
+                value: registrationId,
+            },
+        ], {
+            type: "boolean",
+        });
+    }
+    /**
+     * 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 {@link 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.
+     */
+    callAsync(objectPath, interfaceName, methodName, flags, timeoutMsec, busName, parameters, replyType, cancellable) {
+        return new Promise((resolve, reject) => {
+            call("libgio-2.0.so.0", "g_dbus_connection_call", [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: this.id,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    value: busName,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    value: objectPath,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    value: interfaceName,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    value: methodName,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "gvariant",
+                        ownership: "none",
+                    },
+                    value: parameters,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "none",
+                        innerType: "GVariantType",
+                        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                        getTypeFn: "g_variant_type_get_gtype",
+                    },
+                    value: replyType?.id,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                    value: flags,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    value: timeoutMsec,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: cancellable?.id,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "callback",
+                        trampoline: "asyncReady",
+                        sourceType: { type: "gobject", ownership: "none" },
+                        resultType: { type: "gobject", ownership: "none" },
+                    },
+                    value: (_source, result) => {
+                        const error = { value: null };
+                        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_call_finish", [
+                            {
+                                type: {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                                value: this.id,
+                            },
+                            { type: { type: "gobject", ownership: "none" }, value: result },
+                            {
+                                type: {
+                                    type: "ref",
+                                    innerType: {
+                                        type: "boxed",
+                                        ownership: "full",
+                                        innerType: "GError",
+                                        lib: "libgobject-2.0.so.0",
+                                    },
+                                },
+                                value: error,
+                            },
+                        ], {
+                            type: "gvariant",
+                            ownership: "full",
+                        });
+                        if (error.value !== null) {
+                            reject(new NativeError(getNativeObject(error.value, GLib.GError)));
+                            return;
+                        }
+                        resolve(getNativeObject(ptr, GLib.Variant));
+                    },
+                },
+                { type: { type: "null" }, value: null },
+            ], { type: "undefined" });
+        });
+    }
+    /**
+     * 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.
+     */
+    callWithUnixFdListAsync(objectPath, interfaceName, methodName, flags, timeoutMsec, busName, parameters, replyType, fdList, cancellable) {
+        return new Promise((resolve, reject) => {
+            call("libgio-2.0.so.0", "g_dbus_connection_call_with_unix_fd_list", [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: this.id,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    value: busName,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    value: objectPath,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    value: interfaceName,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "string",
+                        ownership: "none",
+                    },
+                    value: methodName,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "gvariant",
+                        ownership: "none",
+                    },
+                    value: parameters,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "boxed",
+                        ownership: "none",
+                        innerType: "GVariantType",
+                        lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                        getTypeFn: "g_variant_type_get_gtype",
+                    },
+                    value: replyType?.id,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                    value: flags,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    value: timeoutMsec,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: fdList?.id,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: cancellable?.id,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "callback",
+                        trampoline: "asyncReady",
+                        sourceType: { type: "gobject", ownership: "none" },
+                        resultType: { type: "gobject", ownership: "none" },
+                    },
+                    value: (_source, result) => {
+                        const error = { value: null };
+                        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_call_with_unix_fd_list_finish", [
+                            {
+                                type: {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                                value: this.id,
+                            },
+                            { type: { type: "gobject", ownership: "none" }, value: result },
+                            {
+                                type: {
+                                    type: "ref",
+                                    innerType: {
+                                        type: "boxed",
+                                        ownership: "full",
+                                        innerType: "GError",
+                                        lib: "libgobject-2.0.so.0",
+                                    },
+                                },
+                                value: error,
+                            },
+                        ], {
+                            type: "gvariant",
+                            ownership: "full",
+                        });
+                        if (error.value !== null) {
+                            reject(new NativeError(getNativeObject(error.value, GLib.GError)));
+                            return;
+                        }
+                        resolve(getNativeObject(ptr, GLib.Variant));
+                    },
+                },
+                { type: { type: "null" }, value: null },
+            ], { type: "undefined" });
+        });
+    }
+    /**
+     * 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 {@link 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 {@link 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.
+     */
+    closeAsync(cancellable) {
+        return new Promise((resolve, reject) => {
+            call("libgio-2.0.so.0", "g_dbus_connection_close", [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: this.id,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: cancellable?.id,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "callback",
+                        trampoline: "asyncReady",
+                        sourceType: { type: "gobject", ownership: "none" },
+                        resultType: { type: "gobject", ownership: "none" },
+                    },
+                    value: (_source, result) => {
+                        const error = { value: null };
+                        const value = call("libgio-2.0.so.0", "g_dbus_connection_close_finish", [
+                            {
+                                type: {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                                value: this.id,
+                            },
+                            { type: { type: "gobject", ownership: "none" }, value: result },
+                            {
+                                type: {
+                                    type: "ref",
+                                    innerType: {
+                                        type: "boxed",
+                                        ownership: "full",
+                                        innerType: "GError",
+                                        lib: "libgobject-2.0.so.0",
+                                    },
+                                },
+                                value: error,
+                            },
+                        ], {
+                            type: "boolean",
+                        });
+                        if (error.value !== null) {
+                            reject(new NativeError(getNativeObject(error.value, GLib.GError)));
+                            return;
+                        }
+                        resolve(value);
+                    },
+                },
+                { type: { type: "null" }, value: null },
+            ], { type: "undefined" });
+        });
+    }
+    /**
+     * 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 {@link 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.
+     */
+    flushAsync(cancellable) {
+        return new Promise((resolve, reject) => {
+            call("libgio-2.0.so.0", "g_dbus_connection_flush", [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: this.id,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: cancellable?.id,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "callback",
+                        trampoline: "asyncReady",
+                        sourceType: { type: "gobject", ownership: "none" },
+                        resultType: { type: "gobject", ownership: "none" },
+                    },
+                    value: (_source, result) => {
+                        const error = { value: null };
+                        const value = call("libgio-2.0.so.0", "g_dbus_connection_flush_finish", [
+                            {
+                                type: {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                                value: this.id,
+                            },
+                            { type: { type: "gobject", ownership: "none" }, value: result },
+                            {
+                                type: {
+                                    type: "ref",
+                                    innerType: {
+                                        type: "boxed",
+                                        ownership: "full",
+                                        innerType: "GError",
+                                        lib: "libgobject-2.0.so.0",
+                                    },
+                                },
+                                value: error,
+                            },
+                        ], {
+                            type: "boolean",
+                        });
+                        if (error.value !== null) {
+                            reject(new NativeError(getNativeObject(error.value, GLib.GError)));
+                            return;
+                        }
+                        resolve(value);
+                    },
+                },
+                { type: { type: "null" }, value: null },
+            ], { type: "undefined" });
+        });
+    }
+    /**
+     * 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 {@link 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]{@link Gio.DBusConnection#an-example-d-bus-server}
+     * and [client]{@link 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.
+     */
+    sendMessageWithReplyAsync(message, flags, timeoutMsec, outSerial, cancellable) {
+        return new Promise((resolve, reject) => {
+            call("libgio-2.0.so.0", "g_dbus_connection_send_message_with_reply", [
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: this.id,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: message.id,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: true,
+                    },
+                    value: flags,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "int",
+                        size: 32,
+                        unsigned: false,
+                    },
+                    value: timeoutMsec,
+                    optional: false,
+                },
+                {
+                    type: {
+                        type: "ref",
+                        innerType: {
+                            type: "int",
+                            size: 32,
+                            unsigned: true,
+                        },
+                    },
+                    value: outSerial,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "gobject",
+                        ownership: "none",
+                    },
+                    value: cancellable?.id,
+                    optional: true,
+                },
+                {
+                    type: {
+                        type: "callback",
+                        trampoline: "asyncReady",
+                        sourceType: { type: "gobject", ownership: "none" },
+                        resultType: { type: "gobject", ownership: "none" },
+                    },
+                    value: (_source, result) => {
+                        const error = { value: null };
+                        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_send_message_with_reply_finish", [
+                            {
+                                type: {
+                                    type: "gobject",
+                                    ownership: "none",
+                                },
+                                value: this.id,
+                            },
+                            { type: { type: "gobject", ownership: "none" }, value: result },
+                            {
+                                type: {
+                                    type: "ref",
+                                    innerType: {
+                                        type: "boxed",
+                                        ownership: "full",
+                                        innerType: "GError",
+                                        lib: "libgobject-2.0.so.0",
+                                    },
+                                },
+                                value: error,
+                            },
+                        ], {
+                            type: "gobject",
+                            ownership: "full",
+                        });
+                        if (error.value !== null) {
+                            reject(new NativeError(getNativeObject(error.value, GLib.GError)));
+                            return;
+                        }
+                        resolve(getNativeObject(ptr));
+                    },
+                },
+                { type: { type: "null" }, value: null },
+            ], { 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.
+     */
+    initAsync(ioPriority, cancellable, callback) {
+        const wrappedCallback = callback
+            ? (...args) => callback(getNativeObject(args[0]), getNativeObject(args[1], AsyncResult))
+            : null;
+        call("libgio-2.0.so.0", "g_async_initable_init_async", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "int",
+                    size: 32,
+                    unsigned: false,
+                },
+                value: ioPriority,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "callback",
+                    trampoline: "asyncReady",
+                    argTypes: [
+                        {
+                            type: "gobject",
+                            ownership: "none",
+                        },
+                        {
+                            type: "gobject",
+                            ownership: "none",
+                        },
+                    ],
+                },
+                value: wrappedCallback,
+                optional: true,
+            },
+        ], {
+            type: "undefined",
+        });
+    }
+    /**
+     * Finishes asynchronous initialization and returns the result.
+     * See g_async_initable_init_async().
+     */
+    initFinish(res) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_async_initable_init_finish", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: res.id,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "boolean",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    /**
+     * Finishes the async construction for the various g_async_initable_new
+     * calls, returning the created object or %NULL on error.
+     */
+    newFinish(res) {
+        const error = { value: null };
+        const ptr = call("libgio-2.0.so.0", "g_async_initable_new_finish", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: res.id,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "gobject",
+            ownership: "full",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return getNativeObject(ptr);
+    }
+    /**
+     * Initializes the object implementing the interface.
+     *
+     * This method is intended for language bindings. If writing in C,
+     * g_initable_new() should typically be used instead.
+     *
+     * The object must be initialized before any real use after initial
+     * construction, either with this function or g_async_initable_init_async().
+     *
+     * 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.
+     *
+     * 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. See the [description]{@link Gio.Initable#description} for more details.
+     *
+     * Callers should not assume that a class which implements #GInitable can be
+     * initialized multiple times, unless the class explicitly documents itself as
+     * supporting this. Generally, a class’ implementation of init() can assume
+     * (and assert) that it will only be called once. Previously, this documentation
+     * recommended all #GInitable implementations should be idempotent; that
+     * recommendation was relaxed in GLib 2.54.
+     *
+     * If a class explicitly supports being initialized multiple times, it is
+     * recommended that the method is idempotent: multiple calls with the same
+     * arguments should return the same results. Only the first call initializes
+     * the object; further calls return the result of the first call.
+     *
+     * One reason why a class might need to support idempotent initialization is if
+     * it is designed to be used via the singleton pattern, with a
+     * #GObjectClass.constructor that sometimes returns an existing instance.
+     * In this pattern, a caller would expect to be able to call g_initable_init()
+     * on the result of g_object_new(), regardless of whether it is in fact a new
+     * instance.
+     */
+    init(cancellable) {
+        const error = { value: null };
+        const result = call("libgio-2.0.so.0", "g_initable_init", [
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: this.id,
+            },
+            {
+                type: {
+                    type: "gobject",
+                    ownership: "none",
+                },
+                value: cancellable?.id,
+                optional: true,
+            },
+            {
+                type: {
+                    type: "ref",
+                    innerType: {
+                        type: "boxed",
+                        ownership: "full",
+                        innerType: "GError",
+                        lib: "libgobject-2.0.so.0",
+                    },
+                },
+                value: error,
+            },
+        ], {
+            type: "boolean",
+        });
+        if (error.value !== null) {
+            throw new NativeError(getNativeObject(error.value, GLib.GError));
+        }
+        return result;
+    }
+    connect(signal, handler, after = false) {
+        switch (signal) {
+            case "closed": {
+                const wrappedHandler = (...args) => {
+                    return handler(getNativeObject(args[0]), args[1], getNativeObject(args[2], GLib.GError));
+                };
+                return call("libgio-2.0.so.0", "g_signal_connect_closure", [
+                    { type: { type: "gobject", ownership: "none" }, value: this.id },
+                    { type: { type: "string", ownership: "none" }, value: signal },
+                    {
+                        type: {
+                            type: "callback",
+                            argTypes: [
+                                { type: "gobject", ownership: "none" },
+                                {
+                                    type: "boolean",
+                                },
+                                {
+                                    type: "boxed",
+                                    ownership: "none",
+                                    innerType: "GError",
+                                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
+                                    getTypeFn: "g_error_get_type",
+                                },
+                            ],
+                            returnType: {
+                                type: "undefined",
+                            },
+                            trampoline: "closure",
+                        },
+                        value: wrappedHandler,
+                    },
+                    { type: { type: "boolean" }, value: after },
+                ], { type: "int", size: 64, unsigned: true });
+            }
+            default:
+                return super.connect(signal, handler, after);
+        }
+    }
+}
+registerNativeClass(DBusConnection);