@gtkx/ffi 0.1.44 → 0.1.46

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

@@ -5,6 +5,56 @@ import { DBusConnection } from "./dbus-connection.js";
 import { DBusObject } from "./dbus-object.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GDBusProxy` is a base class used for proxies to access a D-Bus
+ * interface on a remote object. A `GDBusProxy` can be constructed for
+ * both well-known and unique names.
+ *
+ * By default, `GDBusProxy` will cache all properties (and listen to
+ * changes) of the remote object, and proxy all signals that get
+ * emitted. This behaviour can be changed by passing suitable
+ * [flags@Gio.DBusProxyFlags] when the proxy is created. If the proxy is for a
+ * well-known name, the property cache is flushed when the name owner
+ * vanishes and reloaded when a name owner appears.
+ *
+ * The unique name owner of the proxy’s name is tracked and can be read from
+ * [property@Gio.DBusProxy:g-name-owner]. Connect to the
+ * [signal@GObject.Object::notify] signal to get notified of changes.
+ * Additionally, only signals and property changes emitted from the current name
+ * owner are considered and calls are always sent to the current name owner.
+ * This avoids a number of race conditions when the name is lost by one owner
+ * and claimed by another. However, if no name owner currently exists,
+ * then calls will be sent to the well-known name which may result in
+ * the message bus launching an owner (unless
+ * `G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START` is set).
+ *
+ * If the proxy is for a stateless D-Bus service, where the name owner may
+ * be started and stopped between calls, the
+ * [property@Gio.DBusProxy:g-name-owner] tracking of `GDBusProxy` will cause the
+ * proxy to drop signal and property changes from the service after it has
+ * restarted for the first time. When interacting with a stateless D-Bus
+ * service, do not use `GDBusProxy` — use direct D-Bus method calls and signal
+ * connections.
+ *
+ * The generic [signal@Gio.DBusProxy::g-properties-changed] and
+ * [signal@Gio.DBusProxy::g-signal] signals are not very convenient to work
+ * with. Therefore, the recommended way of working with proxies is to subclass
+ * `GDBusProxy`, and have more natural properties and signals in your derived
+ * class. This example shows how
+ * this can easily be done using the `gdbus-codegen` tool.
+ *
+ * A `GDBusProxy` instance can be used from multiple threads but note
+ * that all signals (e.g. [signal@Gio.DBusProxy::g-signal],
+ * [signal@Gio.DBusProxy::g-properties-changed] and
+ * [signal@GObject.Object::notify]) are emitted in the thread-default main
+ * context (see [method@GLib.MainContext.push_thread_default]) of the thread
+ * where the instance was constructed.
+ *
+ *
+ * ## A watch proxy example
+ * An example using a proxy for a well-known name can be found in
+ * [`gdbus-example-watch-proxy.c`](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-watch-proxy.c).
+ */
 const SIGNAL_META = {
     "g-properties-changed": {
         params: [
@@ -28,6 +78,10 @@ export class DBusProxy extends GObject.GObject {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Finishes creating a #GDBusProxy.
+     * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new_for_bus().
+     */
     static proxyNewForBusFinish(res) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_new_for_bus_finish", [
             {
@@ -37,6 +91,18 @@ export class DBusProxy extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, DBusProxy);
     }
+    /**
+     * Like g_dbus_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
+     *
+     * #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
+     * @param busType - A #GBusType.
+     * @param flags - Flags used when constructing the proxy.
+     * @param info - A #GDBusInterfaceInfo specifying the minimal interface
+     * @param name - A bus name (well-known or unique).
+     * @param objectPath - An object path.
+     * @param interfaceName - A D-Bus interface name.
+     * @param cancellable - A #GCancellable or %NULL.
+     */
     static proxyNewForBusSync(busType, flags, name, objectPath, interfaceName, info, cancellable) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_new_for_bus_sync", [
             {
@@ -77,6 +143,37 @@ export class DBusProxy extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, DBusProxy);
     }
+    /**
+     * Creates a proxy for accessing `interface_name` on the remote object
+     * at `object_path` owned by `name` at `connection` and synchronously
+     * loads D-Bus properties unless the
+     * %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used.
+     *
+     * If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
+     * match rules for signals. Connect to the #GDBusProxy::g-signal signal
+     * to handle signals from the remote object.
+     *
+     * If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and
+     * %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is
+     * guaranteed to return immediately without blocking.
+     *
+     * If `name` is a well-known name and the
+     * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION
+     * flags aren't set and no name owner currently exists, the message bus
+     * will be requested to launch a name owner for the name.
+     *
+     * This is a synchronous failable constructor. See g_dbus_proxy_new()
+     * and g_dbus_proxy_new_finish() for the asynchronous version.
+     *
+     * #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
+     * @param connection - A #GDBusConnection.
+     * @param flags - Flags used when constructing the proxy.
+     * @param info - A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
+     * @param name - A bus name (well-known or unique) or %NULL if `connection` is not a message bus connection.
+     * @param objectPath - An object path.
+     * @param interfaceName - A D-Bus interface name.
+     * @param cancellable - A #GCancellable or %NULL.
+     */
     static proxyNewSync(connection, flags, objectPath, interfaceName, info, name, cancellable) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_new_sync", [
             {
@@ -127,6 +224,44 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Creates a proxy for accessing `interface_name` on the remote object
+     * at `object_path` owned by `name` at `connection` and asynchronously
+     * loads D-Bus properties unless the
+     * %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to
+     * the #GDBusProxy::g-properties-changed signal to get notified about
+     * property changes.
+     *
+     * If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
+     * match rules for signals. Connect to the #GDBusProxy::g-signal signal
+     * to handle signals from the remote object.
+     *
+     * If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and
+     * %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is
+     * guaranteed to complete immediately without blocking.
+     *
+     * If `name` is a well-known name and the
+     * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION
+     * flags aren't set and no name owner currently exists, the message bus
+     * will be requested to launch a name owner for the name.
+     *
+     * This is a failable asynchronous constructor - when the proxy is
+     * ready, `callback` will be invoked and you can use
+     * g_dbus_proxy_new_finish() to get the result.
+     *
+     * See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
+     *
+     * #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
+     * @param connection - A #GDBusConnection.
+     * @param flags - Flags used when constructing the proxy.
+     * @param info - A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
+     * @param name - A bus name (well-known or unique) or %NULL if `connection` is not a message bus connection.
+     * @param objectPath - An object path.
+     * @param interfaceName - A D-Bus interface name.
+     * @param cancellable - A #GCancellable or %NULL.
+     * @param callback - Callback function to invoke when the proxy is ready.
+     * @param userData - User data to pass to @callback.
+     */
     static _new(connection, flags, objectPath, interfaceName, info, name, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_dbus_proxy_new", [
             {
@@ -177,6 +312,20 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Like g_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+     *
+     * #GDBusProxy is used in this [example][class@Gio.DBusProxy#a-watch-proxy-example].
+     * @param busType - A #GBusType.
+     * @param flags - Flags used when constructing the proxy.
+     * @param info - A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
+     * @param name - A bus name (well-known or unique).
+     * @param objectPath - An object path.
+     * @param interfaceName - A D-Bus interface name.
+     * @param cancellable - A #GCancellable or %NULL.
+     * @param callback - Callback function to invoke when the proxy is ready.
+     * @param userData - User data to pass to @callback.
+     */
     static newForBus(busType, flags, name, objectPath, interfaceName, info, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_dbus_proxy_new_for_bus", [
             {
@@ -226,6 +375,57 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Asynchronously invokes the `method_name` method on @proxy.
+     *
+     * If `method_name` contains any dots, then `name` is split into interface and
+     * method name parts. This allows using `proxy` for invoking methods on
+     * other interfaces.
+     *
+     * If the #GDBusConnection associated with `proxy` is closed then
+     * the operation will fail with %G_IO_ERROR_CLOSED. If
+     * `cancellable` is canceled, the operation will fail with
+     * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
+     * compatible with the D-Bus protocol, the operation fails with
+     * %G_IO_ERROR_INVALID_ARGUMENT.
+     *
+     * If the `parameters` #GVariant is floating, it is consumed. This allows
+     * convenient 'inline' use of g_variant_new(), e.g.:
+     * |[<!-- language="C" -->
+     * g_dbus_proxy_call (proxy,
+     * "TwoStrings",
+     * g_variant_new ("(ss)",
+     * "Thing One",
+     * "Thing Two"),
+     * G_DBUS_CALL_FLAGS_NONE,
+     * -1,
+     * NULL,
+     * (GAsyncReadyCallback) two_strings_done,
+     * &data);
+     * ]|
+     *
+     * If `proxy` has an expected interface (see
+     * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
+     * then the return value is checked against the return type.
+     *
+     * This is an asynchronous method. When the operation is finished,
+     * `callback` will be invoked in the thread-default main context
+     * (see [method@GLib.MainContext.push_thread_default])
+     * of the thread you are calling this method from.
+     * You can then call g_dbus_proxy_call_finish() to get the result of
+     * the operation. See g_dbus_proxy_call_sync() for the synchronous
+     * version of this method.
+     *
+     * If `callback` is %NULL then the D-Bus method call message will be sent with
+     * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
+     * @param methodName - Name of method to invoke.
+     * @param parameters - A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
+     * @param flags - Flags from the #GDBusCallFlags enumeration.
+     * @param timeoutMsec - The timeout in milliseconds (with %G_MAXINT meaning
+     * @param cancellable - A #GCancellable or %NULL.
+     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't
+     * @param userData - The data to pass to @callback.
+     */
     call(methodName, flags, timeoutMsec, parameters, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_dbus_proxy_call", [
             {
@@ -271,6 +471,10 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an operation started with g_dbus_proxy_call().
+     * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call().
+     */
     callFinish(res) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_call_finish", [
@@ -304,6 +508,47 @@ export class DBusProxy extends GObject.GObject {
         }
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Synchronously invokes the `method_name` method on @proxy.
+     *
+     * If `method_name` contains any dots, then `name` is split into interface and
+     * method name parts. This allows using `proxy` for invoking methods on
+     * other interfaces.
+     *
+     * If the #GDBusConnection associated with `proxy` is disconnected then
+     * the operation will fail with %G_IO_ERROR_CLOSED. If
+     * `cancellable` is canceled, the operation will fail with
+     * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
+     * compatible with the D-Bus protocol, the operation fails with
+     * %G_IO_ERROR_INVALID_ARGUMENT.
+     *
+     * If the `parameters` #GVariant is floating, it is consumed. This allows
+     * convenient 'inline' use of g_variant_new(), e.g.:
+     * |[<!-- language="C" -->
+     * g_dbus_proxy_call_sync (proxy,
+     * "TwoStrings",
+     * g_variant_new ("(ss)",
+     * "Thing One",
+     * "Thing Two"),
+     * G_DBUS_CALL_FLAGS_NONE,
+     * -1,
+     * NULL,
+     * &error);
+     * ]|
+     *
+     * The calling thread is blocked until a reply is received. See
+     * g_dbus_proxy_call() for the asynchronous version of this
+     * method.
+     *
+     * If `proxy` has an expected interface (see
+     * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
+     * then the return value is checked against the return type.
+     * @param methodName - Name of method to invoke.
+     * @param parameters - A #GVariant tuple with parameters for the signal
+     * @param flags - Flags from the #GDBusCallFlags enumeration.
+     * @param timeoutMsec - The timeout in milliseconds (with %G_MAXINT meaning
+     * @param cancellable - A #GCancellable or %NULL.
+     */
     callSync(methodName, flags, timeoutMsec, parameters, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_call_sync", [
@@ -360,6 +605,19 @@ export class DBusProxy extends GObject.GObject {
         }
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
+     *
+     * This method is only available on UNIX.
+     * @param methodName - Name of method to invoke.
+     * @param parameters - A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
+     * @param flags - Flags from the #GDBusCallFlags enumeration.
+     * @param timeoutMsec - The timeout in milliseconds (with %G_MAXINT meaning
+     * @param fdList - A #GUnixFDList or %NULL.
+     * @param cancellable - A #GCancellable or %NULL.
+     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't
+     * @param userData - The data to pass to @callback.
+     */
     callWithUnixFdList(methodName, flags, timeoutMsec, parameters, fdList, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_dbus_proxy_call_with_unix_fd_list", [
             {
@@ -410,6 +668,11 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list().
+     * @param outFdList - Return location for a #GUnixFDList or %NULL.
+     * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call_with_unix_fd_list().
+     */
     callWithUnixFdListFinish(res, outFdList) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_call_with_unix_fd_list_finish", [
@@ -448,6 +711,18 @@ export class DBusProxy extends GObject.GObject {
         }
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Like g_dbus_proxy_call_sync() but also takes and returns #GUnixFDList objects.
+     *
+     * This method is only available on UNIX.
+     * @param methodName - Name of method to invoke.
+     * @param parameters - A #GVariant tuple with parameters for the signal
+     * @param flags - Flags from the #GDBusCallFlags enumeration.
+     * @param timeoutMsec - The timeout in milliseconds (with %G_MAXINT meaning
+     * @param fdList - A #GUnixFDList or %NULL.
+     * @param outFdList - Return location for a #GUnixFDList or %NULL.
+     * @param cancellable - A #GCancellable or %NULL.
+     */
     callWithUnixFdListSync(methodName, flags, timeoutMsec, parameters, fdList, outFdList, cancellable) {
         const error = { value: null };
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_call_with_unix_fd_list_sync", [
@@ -514,6 +789,15 @@ export class DBusProxy extends GObject.GObject {
         }
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Looks up the value for a property from the cache. This call does no
+     * blocking IO.
+     *
+     * If `proxy` has an expected interface (see
+     * #GDBusProxy:g-interface-info) and `property_name` is referenced by
+     * it, then `value` is checked against the type of the property.
+     * @param propertyName - Property name.
+     */
     getCachedProperty(propertyName) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_get_cached_property", [
             {
@@ -534,6 +818,9 @@ export class DBusProxy extends GObject.GObject {
             return null;
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Gets the names of all cached properties on @proxy.
+     */
     getCachedPropertyNames() {
         return call("libgio-2.0.so.0", "g_dbus_proxy_get_cached_property_names", [
             {
@@ -542,6 +829,9 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Gets the connection `proxy` is for.
+     */
     getConnection() {
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_get_connection", [
             {
@@ -551,6 +841,13 @@ export class DBusProxy extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, DBusConnection);
     }
+    /**
+     * Gets the timeout to use if -1 (specifying default timeout) is
+     * passed as `timeout_msec` in the g_dbus_proxy_call() and
+     * g_dbus_proxy_call_sync() functions.
+     *
+     * See the #GDBusProxy:g-default-timeout property for more details.
+     */
     getDefaultTimeout() {
         return call("libgio-2.0.so.0", "g_dbus_proxy_get_default_timeout", [
             {
@@ -559,6 +856,9 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the flags that `proxy` was constructed with.
+     */
     getFlags() {
         return call("libgio-2.0.so.0", "g_dbus_proxy_get_flags", [
             {
@@ -567,6 +867,11 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the #GDBusInterfaceInfo, if any, specifying the interface
+     * that `proxy` conforms to. See the #GDBusProxy:g-interface-info
+     * property for more details.
+     */
     getInterfaceInfo() {
         const ptr = call("libgio-2.0.so.0", "g_dbus_proxy_get_interface_info", [
             {
@@ -583,6 +888,9 @@ export class DBusProxy extends GObject.GObject {
             return null;
         return getObject(ptr, DBusInterfaceInfo);
     }
+    /**
+     * Gets the D-Bus interface name `proxy` is for.
+     */
     getInterfaceName() {
         return call("libgio-2.0.so.0", "g_dbus_proxy_get_interface_name", [
             {
@@ -591,6 +899,13 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the name that `proxy` was constructed for.
+     *
+     * When connected to a message bus, this will usually be non-%NULL.
+     * However, it may be %NULL for a proxy that communicates using a peer-to-peer
+     * pattern.
+     */
     getName() {
         return call("libgio-2.0.so.0", "g_dbus_proxy_get_name", [
             {
@@ -599,6 +914,12 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * The unique name that owns the name that `proxy` is for or %NULL if
+     * no-one currently owns that name. You may connect to the
+     * #GObject::notify signal to track changes to the
+     * #GDBusProxy:g-name-owner property.
+     */
     getNameOwner() {
         return call("libgio-2.0.so.0", "g_dbus_proxy_get_name_owner", [
             {
@@ -607,6 +928,9 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the object path `proxy` is for.
+     */
     getObjectPath() {
         return call("libgio-2.0.so.0", "g_dbus_proxy_get_object_path", [
             {
@@ -615,6 +939,42 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * If `value` is not %NULL, sets the cached value for the property with
+     * name `property_name` to the value in @value.
+     *
+     * If `value` is %NULL, then the cached value is removed from the
+     * property cache.
+     *
+     * If `proxy` has an expected interface (see
+     * #GDBusProxy:g-interface-info) and `property_name` is referenced by
+     * it, then `value` is checked against the type of the property.
+     *
+     * If the `value` #GVariant is floating, it is consumed. This allows
+     * convenient 'inline' use of g_variant_new(), e.g.
+     * |[<!-- language="C" -->
+     * g_dbus_proxy_set_cached_property (proxy,
+     * "SomeProperty",
+     * g_variant_new ("(si)",
+     * "A String",
+     * 42));
+     * ]|
+     *
+     * Normally you will not need to use this method since `proxy` is tracking changes using the
+     * `org.freedesktop.DBus.Properties.PropertiesChanged`
+     * D-Bus signal. However, for performance reasons an object may
+     * decide to not use this signal for some properties and instead
+     * use a proprietary out-of-band mechanism to transmit changes.
+     *
+     * As a concrete example, consider an object with a property
+     * `ChatroomParticipants` which is an array of strings. Instead of
+     * transmitting the same (long) array every time the property changes,
+     * it is more efficient to only transmit the delta using e.g. signals
+     * `ChatroomParticipantJoined(String name)` and
+     * `ChatroomParticipantParted(String name)`.
+     * @param propertyName - Property name.
+     * @param value - Value for the property or %NULL to remove it from the cache.
+     */
     setCachedProperty(propertyName, value) {
         call("libgio-2.0.so.0", "g_dbus_proxy_set_cached_property", [
             {
@@ -637,6 +997,14 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the timeout to use if -1 (specifying default timeout) is
+     * passed as `timeout_msec` in the g_dbus_proxy_call() and
+     * g_dbus_proxy_call_sync() functions.
+     *
+     * See the #GDBusProxy:g-default-timeout property for more details.
+     * @param timeoutMsec - Timeout in milliseconds.
+     */
     setDefaultTimeout(timeoutMsec) {
         call("libgio-2.0.so.0", "g_dbus_proxy_set_default_timeout", [
             {
@@ -649,6 +1017,12 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Ensure that interactions with `proxy` conform to the given
+     * interface. See the #GDBusProxy:g-interface-info property for more
+     * details.
+     * @param info - Minimum interface this proxy conforms to
+     */
     setInterfaceInfo(info) {
         call("libgio-2.0.so.0", "g_dbus_proxy_set_interface_info", [
             {
@@ -667,6 +1041,48 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Starts asynchronous initialization of the object implementing the
+     * interface. This must be done before any real use of the object after
+     * initial construction. If the object also implements #GInitable you can
+     * optionally call g_initable_init() instead.
+     *
+     * This method is intended for language bindings. If writing in C,
+     * g_async_initable_new_async() should typically be used instead.
+     *
+     * When the initialization is finished, `callback` will be called. You can
+     * then call g_async_initable_init_finish() to get the result of the
+     * initialization.
+     *
+     * Implementations may also support cancellation. If `cancellable` is not
+     * %NULL, then initialization can be cancelled by triggering the cancellable
+     * object from another thread. If the operation was cancelled, the error
+     * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+     * the object doesn't support cancellable initialization, the error
+     * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+     *
+     * As with #GInitable, if the object is not initialized, or initialization
+     * returns with an error, then all operations on the object except
+     * g_object_ref() and g_object_unref() are considered to be invalid, and
+     * have undefined behaviour. They will often fail with g_critical() or
+     * g_warning(), but this must not be relied on.
+     *
+     * Callers should not assume that a class which implements #GAsyncInitable can
+     * be initialized multiple times; for more information, see g_initable_init().
+     * If a class explicitly supports being initialized multiple times,
+     * implementation requires yielding all subsequent calls to init_async() on the
+     * results of the first call.
+     *
+     * For classes that also support the #GInitable interface, the default
+     * implementation of this method will run the g_initable_init() function
+     * in a thread, so if you want to support asynchronous initialization via
+     * threads, just implement the #GAsyncInitable interface without overriding
+     * any interface methods.
+     * @param ioPriority - the I/O priority of the operation
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     * @param callback - a #GAsyncReadyCallback to call when the request is satisfied
+     * @param userData - the data to pass to callback function
+     */
     initAsync(ioPriority, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_async_initable_init_async", [
             {
@@ -694,6 +1110,11 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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", [
@@ -722,6 +1143,11 @@ export class DBusProxy extends GObject.GObject {
         }
         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", [
@@ -750,6 +1176,9 @@ export class DBusProxy extends GObject.GObject {
         }
         return getObject(ptr, GObject.GObject);
     }
+    /**
+     * Gets the #GDBusObject that `interface_` belongs to, if any.
+     */
     dupObject() {
         const ptr = call("libgio-2.0.so.0", "g_dbus_interface_dup_object", [
             {
@@ -761,6 +1190,10 @@ export class DBusProxy extends GObject.GObject {
             return null;
         return getObject(ptr, DBusObject);
     }
+    /**
+     * Gets D-Bus introspection information for the D-Bus interface
+     * implemented by @interface_.
+     */
     getInfo() {
         const ptr = call("libgio-2.0.so.0", "g_dbus_interface_get_info", [
             {
@@ -775,6 +1208,12 @@ export class DBusProxy extends GObject.GObject {
         });
         return getObject(ptr, DBusInterfaceInfo);
     }
+    /**
+     * Sets the #GDBusObject for `interface_` to @object.
+     *
+     * Note that `interface_` will hold a weak reference to @object.
+     * @param object - A #GDBusObject or %NULL.
+     */
     setObject(object) {
         call("libgio-2.0.so.0", "g_dbus_interface_set_object", [
             {
@@ -788,6 +1227,47 @@ export class DBusProxy extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * 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][iface@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", [