@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gio/{dbus-connection.d.ts → d-bus-connection.d.ts}

@@ -1,30 +1,80 @@
 import { Ref } from "@gtkx/native";
 import { DBusCallFlags, DBusCapabilityFlags, DBusConnectionFlags, DBusSendMessageFlags, DBusSubtreeFlags } from "./enums.js";
-import { DBusInterfaceInfo } from "./dbus-interface-info.js";
+import { DBusInterfaceInfo } from "./d-bus-interface-info.js";
+import { DBusInterfaceVTable } from "./d-bus-interface-v-table.js";
+import { DBusSubtreeVTable } from "./d-bus-subtree-v-table.js";
 import { ActionGroup } from "./action-group.js";
 import { AsyncResult } from "./async-result.js";
 import { Cancellable } from "./cancellable.js";
 import { Credentials } from "./credentials.js";
-import { DBusAuthObserver } from "./dbus-auth-observer.js";
-import { DBusMessage } from "./dbus-message.js";
-import { IOStream } from "./iostream.js";
+import { DBusAuthObserver } from "./d-bus-auth-observer.js";
+import { DBusMessage } from "./d-bus-message.js";
+import { IOStream } from "./io-stream.js";
 import { MenuModel } from "./menu-model.js";
-import { UnixFDList } from "./unix-fdlist.js";
+import { UnixFDList } from "./unix-fd-list.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 declare class DBusConnection extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
-    /**
-     * Finishes an operation started with g_dbus_connection_new().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback
-     */
+    /** Finishes an operation started with g_dbus_connection_new(). */
     constructor(res: AsyncResult);
-    /**
-     * Finishes an operation started with g_dbus_connection_new_for_address().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
-     */
-    static connectionNewForAddressFinish(res: AsyncResult): DBusConnection;
+    /** Finishes an operation started with g_dbus_connection_new_for_address(). */
+    static newForAddressFinish(res: AsyncResult): DBusConnection;
     /**
      * Synchronously connects and sets up a D-Bus client connection for
      * exchanging D-Bus messages with an endpoint specified by `address`
@@ -43,12 +93,8 @@ export declare class DBusConnection extends GObject.GObject {
      *
      * 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: string, flags: DBusConnectionFlags, observer?: DBusAuthObserver, cancellable?: Cancellable): DBusConnection;
+    static newForAddressSync(address: string, flags: DBusConnectionFlags, observer?: DBusAuthObserver | null, cancellable?: Cancellable | null): DBusConnection;
     /**
      * Synchronously sets up a D-Bus connection for exchanging D-Bus messages
      * with the end represented by `stream`.
@@ -65,18 +111,56 @@ export declare class DBusConnection extends GObject.GObject {
      *
      * 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: IOStream, flags: DBusConnectionFlags, guid?: string, observer?: DBusAuthObserver, cancellable?: Cancellable): DBusConnection;
+    static newSync(stream: IOStream, flags: DBusConnectionFlags, guid?: string | null, observer?: DBusAuthObserver | null, cancellable?: Cancellable | null): DBusConnection;
     /**
-     * Finishes an operation started with g_dbus_connection_call().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call()
+     * 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.
      */
-    callFinish(res: AsyncResult): GLib.Variant;
+    static new_(stream: IOStream, flags: DBusConnectionFlags, guid?: string | null, observer?: DBusAuthObserver | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
+    /**
+     * 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: string, flags: DBusConnectionFlags, observer?: DBusAuthObserver | null, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Synchronously invokes the `method_name` method on the
      * `interface_name` D-Bus interface on the remote object at
@@ -96,84 +180,41 @@ export declare class DBusConnection extends GObject.GObject {
      * 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);
+     *  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: string, interfaceName: string, methodName: string, flags: DBusCallFlags, timeoutMsec: number, busName?: string, parameters?: GLib.Variant, replyType?: GLib.VariantType, cancellable?: Cancellable): 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: AsyncResult, outFdList?: Ref<UnixFDList>): GLib.Variant;
+    callSync(objectPath: string, interfaceName: string, methodName: string, flags: DBusCallFlags, timeoutMsec: number, busName?: string | null, parameters?: GLib.Variant | null, replyType?: GLib.VariantType | null, cancellable?: Cancellable | null): 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: string, interfaceName: string, methodName: string, flags: DBusCallFlags, timeoutMsec: number, busName?: string, parameters?: GLib.Variant, replyType?: GLib.VariantType, fdList?: UnixFDList, outFdList?: Ref<UnixFDList>, cancellable?: Cancellable): GLib.Variant;
-    /**
-     * Finishes an operation started with g_dbus_connection_close().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
-     */
-    closeFinish(res: AsyncResult): boolean;
+    callWithUnixFdListSync(objectPath: string, interfaceName: string, methodName: string, flags: DBusCallFlags, timeoutMsec: number, busName?: string | null, parameters?: GLib.Variant | null, replyType?: GLib.VariantType | null, fdList?: UnixFDList | null, outFdList?: Ref<UnixFDList> | null, cancellable?: Cancellable | null): 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.
-     * @param cancellable - a #GCancellable or %NULL
      */
-    closeSync(cancellable?: Cancellable): boolean;
+    closeSync(cancellable?: Cancellable | null): boolean;
     /**
      * Emits a signal.
      *
@@ -182,13 +223,8 @@ export declare class DBusConnection extends GObject.GObject {
      * 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: string, interfaceName: string, signalName: string, destinationBusName?: string, parameters?: GLib.Variant): boolean;
+    emitSignal(objectPath: string, interfaceName: string, signalName: string, destinationBusName?: string | null, parameters?: GLib.Variant | null): boolean;
     /**
      * Exports `action_group` on `connection` at `object_path`.
      *
@@ -211,8 +247,6 @@ export declare class DBusConnection extends GObject.GObject {
      * 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: string, actionGroup: ActionGroup): number;
     /**
@@ -232,26 +266,16 @@ export declare class DBusConnection extends GObject.GObject {
      * 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: string, menu: MenuModel): number;
-    /**
-     * Finishes an operation started with g_dbus_connection_flush().
-     * @param res - a #GAsyncResult obtained from the #GAsyncReadyCallback passed
-     */
-    flushFinish(res: AsyncResult): boolean;
     /**
      * 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?: Cancellable): boolean;
-    /**
-     * Gets the capabilities negotiated with the remote peer
      */
+    flushSync(cancellable?: Cancellable | null): boolean;
+    /** Gets the capabilities negotiated with the remote peer */
     getCapabilities(): DBusCapabilityFlags;
     /**
      * Gets whether the process is terminated when `connection` is
@@ -259,9 +283,7 @@ export declare class DBusConnection extends GObject.GObject {
      * #GDBusConnection:exit-on-close for more details.
      */
     getExitOnClose(): boolean;
-    /**
-     * Gets the flags used to construct this connection
-     */
+    /** Gets the flags used to construct this connection */
     getFlags(): DBusConnectionFlags;
     /**
      * The GUID of the peer performing the role of server when
@@ -302,9 +324,7 @@ export declare class DBusConnection extends GObject.GObject {
      * message bus connection.
      */
     getUniqueName(): string | null;
-    /**
-     * Gets whether `connection` is closed.
-     */
+    /** Gets whether `connection` is closed. */
     isClosed(): boolean;
     /**
      * Registers callbacks for exported objects at `object_path` with the
@@ -346,13 +366,8 @@ export declare class DBusConnection extends GObject.GObject {
      *
      * 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: string, interfaceInfo: DBusInterfaceInfo, userDataFreeFunc: () => void, vtable?: number, userData?: number): number;
+    registerObject(objectPath: string, interfaceInfo: DBusInterfaceInfo, userDataFreeFunc: () => void, vtable?: DBusInterfaceVTable | null, userData?: number | null): number;
     /**
      * Version of g_dbus_connection_register_object() using closures instead of a
      * #GDBusInterfaceVTable for easier binding in other languages.
@@ -361,13 +376,8 @@ export declare class DBusConnection extends GObject.GObject {
      * `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: string, interfaceInfo: DBusInterfaceInfo, methodCallClosure?: GObject.Closure, getPropertyClosure?: GObject.Closure, setPropertyClosure?: GObject.Closure): number;
+    registerObjectWithClosures(objectPath: string, interfaceInfo: DBusInterfaceInfo, methodCallClosure?: GObject.Closure | null, getPropertyClosure?: GObject.Closure | null, setPropertyClosure?: GObject.Closure | null): number;
     /**
      * Version of {@link Gio.DBusConnection.register_object} using closures instead
      * of a {@link Gio.DBusInterfaceVTable} for easier binding in other languages.
@@ -381,13 +391,8 @@ export declare class DBusConnection extends GObject.GObject {
      * {@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: string, interfaceInfo: DBusInterfaceInfo, methodCallClosure?: GObject.Closure, getPropertyClosure?: GObject.Closure, setPropertyClosure?: GObject.Closure): number;
+    registerObjectWithClosures2(objectPath: string, interfaceInfo: DBusInterfaceInfo, methodCallClosure?: GObject.Closure | null, getPropertyClosure?: GObject.Closure | null, setPropertyClosure?: GObject.Closure | null): number;
     /**
      * Registers a whole subtree of dynamic objects.
      *
@@ -423,13 +428,8 @@ export declare class DBusConnection extends GObject.GObject {
      *
      * 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: string, vtable: number, flags: DBusSubtreeFlags, userDataFreeFunc: () => void, userData?: number): number;
+    registerSubtree(objectPath: string, vtable: DBusSubtreeVTable, flags: DBusSubtreeFlags, userDataFreeFunc: () => void, userData?: number | null): number;
     /**
      * Removes a filter.
      *
@@ -439,7 +439,6 @@ export declare class DBusConnection extends GObject.GObject {
      * 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: number): void;
     /**
@@ -465,26 +464,8 @@ export declare class DBusConnection extends GObject.GObject {
      *
      * 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: DBusMessage, flags: DBusSendMessageFlags, outSerial?: Ref<number>): boolean;
-    /**
-     * 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: AsyncResult): DBusMessage;
+    sendMessage(message: DBusMessage, flags: DBusSendMessageFlags, outSerial?: Ref<number> | null): boolean;
     /**
      * Synchronously sends `message` to the peer represented by `connection`
      * and blocks the calling thread until a reply is received or the
@@ -517,13 +498,8 @@ export declare class DBusConnection extends GObject.GObject {
      *
      * 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: DBusMessage, flags: DBusSendMessageFlags, timeoutMsec: number, outSerial?: Ref<number>, cancellable?: Cancellable): DBusMessage;
+    sendMessageWithReplySync(message: DBusMessage, flags: DBusSendMessageFlags, timeoutMsec: number, outSerial?: Ref<number> | null, cancellable?: Cancellable | null): DBusMessage;
     /**
      * Sets whether the process should be terminated when `connection` is
      * closed by the remote peer. See #GDBusConnection:exit-on-close for
@@ -535,7 +511,6 @@ export declare class DBusConnection extends GObject.GObject {
      * 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: boolean): void;
     /**
@@ -551,7 +526,6 @@ export declare class DBusConnection extends GObject.GObject {
      * 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: number): void;
     /**
@@ -568,7 +542,6 @@ export declare class DBusConnection extends GObject.GObject {
      * 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: number): void;
     /**
@@ -578,29 +551,202 @@ export declare class DBusConnection extends GObject.GObject {
      * 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: number): void;
+    /** Unregisters an object. */
+    unregisterObject(registrationId: number): boolean;
+    /** Unregisters a subtree. */
+    unregisterSubtree(registrationId: number): 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: string, interfaceName: string, methodName: string, flags: DBusCallFlags, timeoutMsec: number, busName?: string | null, parameters?: GLib.Variant | null, replyType?: GLib.VariantType | null, cancellable?: Cancellable | null): Promise<GLib.Variant>;
     /**
-     * Unregisters an object.
-     * @param registrationId - a registration id obtained from
+     * 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.
      */
-    unregisterObject(registrationId: number): boolean;
+    callWithUnixFdListAsync(objectPath: string, interfaceName: string, methodName: string, flags: DBusCallFlags, timeoutMsec: number, busName?: string | null, parameters?: GLib.Variant | null, replyType?: GLib.VariantType | null, fdList?: UnixFDList | null, cancellable?: Cancellable | null): Promise<GLib.Variant>;
     /**
-     * Unregisters a subtree.
-     * @param registrationId - a subtree registration id obtained from
+     * 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?: Cancellable | null): Promise<boolean>;
+    /**
+     * 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.
      */
-    unregisterSubtree(registrationId: number): boolean;
+    flushAsync(cancellable?: Cancellable | null): Promise<boolean>;
+    /**
+     * 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: DBusMessage, flags: DBusSendMessageFlags, timeoutMsec: number, outSerial?: Ref<number> | null, cancellable?: Cancellable | null): Promise<DBusMessage>;
+    /**
+     * 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: number, cancellable?: Cancellable | null, callback?: (source_object: GObject.GObject | null, res: AsyncResult) => void | null): void;
     /**
      * Finishes asynchronous initialization and returns the result.
      * See g_async_initable_init_async().
-     * @param res - a #GAsyncResult.
      */
     initFinish(res: AsyncResult): boolean;
     /**
      * 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: AsyncResult): GObject.GObject;
     /**
@@ -642,10 +788,8 @@ export declare class DBusConnection extends GObject.GObject {
      * 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?: Cancellable): boolean;
+    init(cancellable?: Cancellable | null): boolean;
     connect(signal: "closed", handler: (self: DBusConnection, remotePeerVanished: boolean, error: GLib.GError) => void, after?: boolean): number;
-    connect(signal: "notify", handler: (self: DBusConnection, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }