@gtkx/ffi 0.10.5 → 0.11.1

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

@@ -1,1880 +0,0 @@
-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, getNativeClass } from "../../registry.js";
-import * as GLib from "../glib/index.js";
-import * as GObject from "../gobject/index.js";
-/**
- * The `GDBusConnection` type is used for D-Bus connections to remote
- * 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)
- */
-const SIGNAL_META = {
-    closed: {
-        params: [
-            { type: "boolean" },
-            {
-                type: "boxed",
-                borrowed: true,
-                innerType: "GError",
-                lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                getTypeFn: "g_error_get_type",
-            },
-        ],
-        returnType: { type: "undefined" },
-    },
-    notify: {
-        params: [{ type: "gparam", borrowed: true }],
-        returnType: { type: "undefined" },
-    },
-};
-export class DBusConnection extends GObject.GObject {
-    static glibTypeName = "GDBusConnection";
-    static objectType = "gobject";
-    /**
-     * Finishes an operation started with g_dbus_connection_new().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback
-     */
-    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", borrowed: true },
-                    value: res?.id ?? res,
-                },
-            ], { type: "gobject", borrowed: false });
-        }
-        else {
-            // @ts-ignore
-            super();
-        }
-    }
-    /**
-     * Finishes an operation started with g_dbus_connection_new_for_address().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
-     */
-    static connectionNewForAddressFinish(res) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_new_for_address_finish", [
-            {
-                type: { type: "gobject", borrowed: true },
-                value: res?.id ?? res,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gobject", borrowed: false });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param address - a D-Bus address
-     * @param flags - flags describing how to make the connection
-     * @param observer - a #GDBusAuthObserver or %NULL
-     * @param cancellable - a #GCancellable or %NULL
-     */
-    static connectionNewForAddressSync(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", borrowed: true },
-                value: address,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: observer?.id ?? observer,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gobject", borrowed: false });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param stream - a #GIOStream
-     * @param guid - the GUID to use if authenticating as a server or %NULL
-     * @param flags - flags describing how to make the connection
-     * @param observer - a #GDBusAuthObserver or %NULL
-     * @param cancellable - a #GCancellable or %NULL
-     */
-    static connectionNewSync(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", borrowed: true },
-                value: stream?.id ?? stream,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: guid,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: flags,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: observer?.id ?? observer,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gobject", borrowed: false });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return getNativeObject(ptr);
-    }
-    /**
-     * Finishes an operation started with g_dbus_connection_call().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call()
-     */
-    callFinish(res) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_call_finish", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: res?.id ?? res,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gvariant" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return getNativeObject(ptr, GLib.Variant);
-    }
-    /**
-     * 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.
-     * @param busName - a unique or well-known bus name or %NULL if
-     * @param objectPath - path of remote object
-     * @param interfaceName - D-Bus interface to invoke method on
-     * @param methodName - the name of the method to invoke
-     * @param parameters - a #GVariant tuple with parameters for the method
-     * @param replyType - the expected type of the reply, or %NULL
-     * @param flags - flags from the #GDBusCallFlags enumeration
-     * @param timeoutMsec - the timeout in milliseconds, -1 to use the default
-     * @param cancellable - a #GCancellable or %NULL
-     */
-    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" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: busName,
-                optional: true,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: interfaceName,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: methodName,
-            },
-            {
-                type: { type: "gvariant" },
-                value: parameters,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariantType",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                    getTypeFn: "g_variant_type_get_gtype",
-                },
-                value: replyType?.id ?? replyType,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: timeoutMsec,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gvariant" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return getNativeObject(ptr, GLib.Variant);
-    }
-    /**
-     * Finishes an operation started with g_dbus_connection_call_with_unix_fd_list().
-     *
-     * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
-     * values in the body of the message. For example,
-     * if g_variant_get_handle() returns 5, that is intended to be a reference
-     * to the file descriptor that can be accessed by
-     * `g_unix_fd_list_get (*out_fd_list, 5, ...)`.
-     *
-     * 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.
-     * @param outFdList - return location for a #GUnixFDList or %NULL
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed to
-     */
-    callWithUnixFdListFinish(res, outFdList) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_call_with_unix_fd_list_finish", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "ref", innerType: { type: "gobject" } },
-                value: outFdList,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: res?.id ?? res,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gvariant" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        if (outFdList)
-            outFdList.value = getNativeObject(outFdList.value);
-        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.
-     * @param busName - a unique or well-known bus name or %NULL
-     * @param objectPath - path of remote object
-     * @param interfaceName - D-Bus interface to invoke method on
-     * @param methodName - the name of the method to invoke
-     * @param parameters - a #GVariant tuple with parameters for
-     * @param replyType - the expected type of the reply, or %NULL
-     * @param flags - flags from the #GDBusCallFlags enumeration
-     * @param timeoutMsec - the timeout in milliseconds, -1 to use the default
-     * @param fdList - a #GUnixFDList or %NULL
-     * @param outFdList - return location for a #GUnixFDList or %NULL
-     * @param cancellable - a #GCancellable or %NULL
-     */
-    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" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: busName,
-                optional: true,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: interfaceName,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: methodName,
-            },
-            {
-                type: { type: "gvariant" },
-                value: parameters,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GVariantType",
-                    lib: "libgobject-2.0.so.0,libglib-2.0.so.0",
-                    getTypeFn: "g_variant_type_get_gtype",
-                },
-                value: replyType?.id ?? replyType,
-                optional: true,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: flags,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: false },
-                value: timeoutMsec,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: fdList?.id ?? fdList,
-                optional: true,
-            },
-            {
-                type: { type: "ref", innerType: { type: "gobject" } },
-                value: outFdList,
-                optional: true,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gvariant" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        if (outFdList)
-            outFdList.value = getNativeObject(outFdList.value);
-        return getNativeObject(ptr, GLib.Variant);
-    }
-    /**
-     * Finishes an operation started with g_dbus_connection_close().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
-     */
-    closeFinish(res) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_dbus_connection_close_finish", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: res?.id ?? res,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return result;
-    }
-    /**
-     * 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.
-     * @param cancellable - a #GCancellable or %NULL
-     */
-    closeSync(cancellable) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_dbus_connection_close_sync", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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).
-     * @param destinationBusName - the unique bus name for the destination
-     * @param objectPath - path of remote object
-     * @param interfaceName - D-Bus interface to emit a signal on
-     * @param signalName - the name of the signal to emit
-     * @param parameters - a #GVariant tuple with parameters for the signal
-     */
-    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" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: destinationBusName,
-                optional: true,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: interfaceName,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: signalName,
-            },
-            {
-                type: { type: "gvariant" },
-                value: parameters,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param objectPath - a D-Bus object path
-     * @param actionGroup - an action group
-     */
-    exportActionGroup(objectPath, actionGroup) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_dbus_connection_export_action_group", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: actionGroup?.id ?? actionGroup,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "int", size: 32, unsigned: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param objectPath - a D-Bus object path
-     * @param menu - a #GMenuModel
-     */
-    exportMenuModel(objectPath, menu) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_dbus_connection_export_menu_model", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: menu?.id ?? menu,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "int", size: 32, unsigned: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return result;
-    }
-    /**
-     * Finishes an operation started with g_dbus_connection_flush().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
-     */
-    flushFinish(res) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_dbus_connection_flush_finish", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: res?.id ?? res,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param cancellable - a #GCancellable or %NULL
-     */
-    flushSync(cancellable) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_dbus_connection_flush_sync", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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" },
-                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" },
-                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" },
-                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" },
-                value: this.id,
-            },
-        ], { type: "string", borrowed: true });
-    }
-    /**
-     * 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" },
-                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" },
-                value: this.id,
-            },
-        ], { type: "gobject", borrowed: true });
-        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" },
-                value: this.id,
-            },
-        ], { type: "gobject", borrowed: true });
-        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" },
-                value: this.id,
-            },
-        ], { type: "string", borrowed: true });
-    }
-    /**
-     * Gets whether `connection` is closed.
-     */
-    isClosed() {
-        return call("libgio-2.0.so.0", "g_dbus_connection_is_closed", [
-            {
-                type: { type: "gobject" },
-                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.
-     * @param objectPath - the object path to register at
-     * @param interfaceInfo - introspection data for the interface
-     * @param vtable - a #GDBusInterfaceVTable to call into or %NULL
-     * @param userData - data to pass to functions in `vtable`
-     * @param userDataFreeFunc - function to call when the object path is unregistered
-     */
-    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" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GDBusInterfaceInfo",
-                    lib: "libgio-2.0.so.0",
-                    getTypeFn: "g_dbus_interface_info_get_type",
-                },
-                value: interfaceInfo?.id ?? interfaceInfo,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: vtable,
-                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",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "int", size: 32, unsigned: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param objectPath - The object path to register at.
-     * @param interfaceInfo - Introspection data for the interface.
-     * @param methodCallClosure - #GClosure for handling incoming method calls.
-     * @param getPropertyClosure - #GClosure for getting a property.
-     * @param setPropertyClosure - #GClosure for setting a property.
-     */
-    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" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GDBusInterfaceInfo",
-                    lib: "libgio-2.0.so.0",
-                    getTypeFn: "g_dbus_interface_info_get_type",
-                },
-                value: interfaceInfo?.id ?? interfaceInfo,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GClosure",
-                    lib: "libgobject-2.0.so.0",
-                    getTypeFn: "g_closure_get_type",
-                },
-                value: methodCallClosure?.id ?? methodCallClosure,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GClosure",
-                    lib: "libgobject-2.0.so.0",
-                    getTypeFn: "g_closure_get_type",
-                },
-                value: getPropertyClosure?.id ?? getPropertyClosure,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GClosure",
-                    lib: "libgobject-2.0.so.0",
-                    getTypeFn: "g_closure_get_type",
-                },
-                value: setPropertyClosure?.id ?? setPropertyClosure,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "int", size: 32, unsigned: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param objectPath - The object path to register at.
-     * @param interfaceInfo - Introspection data for the interface.
-     * @param methodCallClosure - {@link GObject.Closure} for handling incoming method calls.
-     * @param getPropertyClosure - {@link GObject.Closure} for getting a property.
-     * @param setPropertyClosure - {@link GObject.Closure} for setting a property.
-     */
-    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" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GDBusInterfaceInfo",
-                    lib: "libgio-2.0.so.0",
-                    getTypeFn: "g_dbus_interface_info_get_type",
-                },
-                value: interfaceInfo?.id ?? interfaceInfo,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GClosure",
-                    lib: "libgobject-2.0.so.0",
-                    getTypeFn: "g_closure_get_type",
-                },
-                value: methodCallClosure?.id ?? methodCallClosure,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GClosure",
-                    lib: "libgobject-2.0.so.0",
-                    getTypeFn: "g_closure_get_type",
-                },
-                value: getPropertyClosure?.id ?? getPropertyClosure,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "boxed",
-                    borrowed: true,
-                    innerType: "GClosure",
-                    lib: "libgobject-2.0.so.0",
-                    getTypeFn: "g_closure_get_type",
-                },
-                value: setPropertyClosure?.id ?? setPropertyClosure,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "int", size: 32, unsigned: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param objectPath - the object path to register the subtree at
-     * @param vtable - a #GDBusSubtreeVTable to enumerate, introspect and
-     * @param flags - flags used to fine tune the behavior of the subtree
-     * @param userData - data to pass to functions in `vtable`
-     * @param userDataFreeFunc - function to call when the subtree is unregistered
-     */
-    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" },
-                value: this.id,
-            },
-            {
-                type: { type: "string", borrowed: true },
-                value: objectPath,
-            },
-            {
-                type: { type: "int", size: 64, unsigned: true },
-                value: vtable,
-            },
-            {
-                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",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "int", size: 32, unsigned: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param filterId - an identifier obtained from g_dbus_connection_add_filter()
-     */
-    removeFilter(filterId) {
-        call("libgio-2.0.so.0", "g_dbus_connection_remove_filter", [
-            {
-                type: { type: "gobject" },
-                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.
-     * @param message - a #GDBusMessage
-     * @param flags - flags affecting how the message is sent
-     * @param outSerial - return location for serial number assigned
-     */
-    sendMessage(message, flags, outSerial) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_dbus_connection_send_message", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: message?.id ?? message,
-            },
-            {
-                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",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return result;
-    }
-    /**
-     * Finishes an operation started with g_dbus_connection_send_message_with_reply().
-     *
-     * 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.
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed to
-     */
-    sendMessageWithReplyFinish(res) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_dbus_connection_send_message_with_reply_finish", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: res?.id ?? res,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gobject", borrowed: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return getNativeObject(ptr);
-    }
-    /**
-     * 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.
-     * @param message - a #GDBusMessage
-     * @param flags - flags affecting how the message is sent.
-     * @param timeoutMsec - the timeout in milliseconds, -1 to use the default
-     * @param outSerial - return location for serial number
-     * @param cancellable - a #GCancellable or %NULL
-     */
-    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" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: message?.id ?? message,
-            },
-            {
-                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", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gobject", borrowed: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param exitOnClose - whether the process should be terminated
-     */
-    setExitOnClose(exitOnClose) {
-        call("libgio-2.0.so.0", "g_dbus_connection_set_exit_on_close", [
-            {
-                type: { type: "gobject" },
-                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.
-     * @param subscriptionId - a subscription id obtained from
-     */
-    signalUnsubscribe(subscriptionId) {
-        call("libgio-2.0.so.0", "g_dbus_connection_signal_unsubscribe", [
-            {
-                type: { type: "gobject" },
-                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" },
-                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.
-     * @param exportId - the ID from {@link Gio.DBusConnection.export_action_group}
-     */
-    unexportActionGroup(exportId) {
-        call("libgio-2.0.so.0", "g_dbus_connection_unexport_action_group", [
-            {
-                type: { type: "gobject" },
-                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.
-     * @param exportId - the ID from g_dbus_connection_export_menu_model()
-     */
-    unexportMenuModel(exportId) {
-        call("libgio-2.0.so.0", "g_dbus_connection_unexport_menu_model", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: exportId,
-            },
-        ], { type: "undefined" });
-    }
-    /**
-     * Unregisters an object.
-     * @param registrationId - a registration id obtained from
-     */
-    unregisterObject(registrationId) {
-        return call("libgio-2.0.so.0", "g_dbus_connection_unregister_object", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: registrationId,
-            },
-        ], { type: "boolean" });
-    }
-    /**
-     * Unregisters a subtree.
-     * @param registrationId - a subtree registration id obtained from
-     */
-    unregisterSubtree(registrationId) {
-        return call("libgio-2.0.so.0", "g_dbus_connection_unregister_subtree", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "int", size: 32, unsigned: true },
-                value: registrationId,
-            },
-        ], { type: "boolean" });
-    }
-    /**
-     * Finishes asynchronous initialization and returns the result.
-     * See g_async_initable_init_async().
-     * @param res - a #GAsyncResult.
-     */
-    initFinish(res) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_async_initable_init_finish", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: res?.id ?? res,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return result;
-    }
-    /**
-     * Finishes the async construction for the various g_async_initable_new
-     * calls, returning the created object or %NULL on error.
-     * @param res - the #GAsyncResult from the callback
-     */
-    newFinish(res) {
-        const error = { value: null };
-        const ptr = call("libgio-2.0.so.0", "g_async_initable_new_finish", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: res?.id ?? res,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "gobject", borrowed: true });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        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.
-     * @param cancellable - optional #GCancellable object, %NULL to ignore.
-     */
-    init(cancellable) {
-        const error = { value: null };
-        const result = call("libgio-2.0.so.0", "g_initable_init", [
-            {
-                type: { type: "gobject" },
-                value: this.id,
-            },
-            {
-                type: { type: "gobject", borrowed: true },
-                value: cancellable?.id ?? cancellable,
-                optional: true,
-            },
-            {
-                type: {
-                    type: "ref",
-                    innerType: {
-                        type: "boxed",
-                        innerType: "GError",
-                        lib: "libglib-2.0.so.0",
-                    },
-                },
-                value: error,
-            },
-        ], { type: "boolean" });
-        if (error.value !== null) {
-            throw new NativeError(error.value);
-        }
-        return result;
-    }
-    connect(signal, handler, after = false) {
-        const meta = SIGNAL_META[signal];
-        const selfType = { type: "gobject", borrowed: true };
-        const argTypes = meta ? [selfType, ...meta.params] : [selfType];
-        const returnType = meta?.returnType;
-        const wrappedHandler = (...args) => {
-            const self = getNativeObject(args[0]);
-            const callbackArgs = args.slice(1);
-            if (!meta)
-                return handler(self, ...callbackArgs);
-            const wrapped = meta.params.map((t, i) => {
-                if (t?.type === "gobject" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i]);
-                }
-                if (t?.type === "gparam" && callbackArgs[i] != null) {
-                    return getNativeObject(callbackArgs[i], GObject.ParamSpec);
-                }
-                if (t?.type === "boxed" && callbackArgs[i] != null) {
-                    const cls = getNativeClass(t.innerType);
-                    return cls ? getNativeObject(callbackArgs[i], cls) : callbackArgs[i];
-                }
-                return callbackArgs[i];
-            });
-            const result = handler(self, ...wrapped);
-            return result;
-        };
-        return call("libgio-2.0.so.0", "g_signal_connect_closure", [
-            { type: { type: "gobject" }, value: this.id },
-            { type: { type: "string" }, value: signal },
-            {
-                type: { type: "callback", argTypes, returnType },
-                value: wrappedHandler,
-            },
-            { type: { type: "boolean" }, value: after },
-        ], { type: "int", size: 64, unsigned: true });
-    }
-}
-registerNativeClass(DBusConnection);