@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/gio/dbus-object-manager-client.d.ts

@@ -9,25 +9,230 @@ import { DBusProxy } from "./dbus-proxy.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 export declare class DBusObjectManagerClient extends GObject.GObject {
+    /**
+     * Finishes an operation started with g_dbus_object_manager_client_new().
+     * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new().
+     */
     constructor(res: AsyncResult);
     constructor(...args: unknown[]);
+    /**
+     * Finishes an operation started with g_dbus_object_manager_client_new_for_bus().
+     * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new_for_bus().
+     */
     static objectManagerClientNewForBusFinish(res: AsyncResult): DBusObjectManagerClient;
+    /**
+     * Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead
+     * of a #GDBusConnection.
+     *
+     * This is a synchronous failable constructor - the calling thread is
+     * blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
+     * for the asynchronous version.
+     * @param busType - A #GBusType.
+     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+     * @param name - The owner of the control object (unique or well-known name).
+     * @param objectPath - The object path of the control object.
+     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
+     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
+     * @param cancellable - A #GCancellable or %NULL
+     */
     static objectManagerClientNewForBusSync(busType: BusType, flags: DBusObjectManagerClientFlags, name: string, objectPath: string, getProxyTypeFunc?: (...args: unknown[]) => unknown | null, getProxyTypeUserData?: number | null, getProxyTypeDestroyNotify?: () => void | null, cancellable?: Cancellable | null): DBusObjectManagerClient;
+    /**
+     * Creates a new #GDBusObjectManagerClient object.
+     *
+     * This is a synchronous failable constructor - the calling thread is
+     * blocked until a reply is received. See g_dbus_object_manager_client_new()
+     * for the asynchronous version.
+     * @param connection - A #GDBusConnection.
+     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+     * @param name - The owner of the control object (unique or well-known name), or %NULL when not using a message bus connection.
+     * @param objectPath - The object path of the control object.
+     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
+     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
+     * @param cancellable - A #GCancellable or %NULL
+     */
     static objectManagerClientNewSync(connection: DBusConnection, flags: DBusObjectManagerClientFlags, objectPath: string, name?: string | null, getProxyTypeFunc?: (...args: unknown[]) => unknown | null, getProxyTypeUserData?: number | null, getProxyTypeDestroyNotify?: () => void | null, cancellable?: Cancellable | null): DBusObjectManagerClient;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Asynchronously creates a new #GDBusObjectManagerClient object.
+     *
+     * This is an asynchronous failable constructor. When the result is
+     * ready, `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_object_manager_client_new_finish() to get the result. See
+     * g_dbus_object_manager_client_new_sync() for the synchronous version.
+     * @param connection - A #GDBusConnection.
+     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+     * @param name - The owner of the control object (unique or well-known name).
+     * @param objectPath - The object path of the control object.
+     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
+     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
+     * @param cancellable - A #GCancellable or %NULL
+     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied.
+     * @param userData - The data to pass to @callback.
+     */
     static _new(connection: DBusConnection, flags: DBusObjectManagerClientFlags, name: string, objectPath: string, getProxyTypeFunc?: (...args: unknown[]) => unknown | null, getProxyTypeUserData?: number | null, getProxyTypeDestroyNotify?: () => void | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a
+     * #GDBusConnection.
+     *
+     * This is an asynchronous failable constructor. When the result is
+     * ready, `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_object_manager_client_new_for_bus_finish() to get the result. See
+     * g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
+     * @param busType - A #GBusType.
+     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+     * @param name - The owner of the control object (unique or well-known name).
+     * @param objectPath - The object path of the control object.
+     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
+     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
+     * @param cancellable - A #GCancellable or %NULL
+     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied.
+     * @param userData - The data to pass to @callback.
+     */
     static newForBus(busType: BusType, flags: DBusObjectManagerClientFlags, name: string, objectPath: string, getProxyTypeFunc?: (...args: unknown[]) => unknown | null, getProxyTypeUserData?: number | null, getProxyTypeDestroyNotify?: () => void | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * Gets the #GDBusConnection used by @manager.
+     */
     getConnection(): DBusConnection;
+    /**
+     * Gets the flags that `manager` was constructed with.
+     */
     getFlags(): DBusObjectManagerClientFlags;
+    /**
+     * Gets the name that `manager` is for, or %NULL if not a message bus
+     * connection.
+     */
     getName(): string;
+    /**
+     * The unique name that owns the name that `manager` is for or %NULL if
+     * no-one currently owns that name. You can connect to the
+     * #GObject::notify signal to track changes to the
+     * #GDBusObjectManagerClient:name-owner property.
+     */
     getNameOwner(): string | null;
+    /**
+     * 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: number, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | 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;
+    /**
+     * Gets the interface proxy for `interface_name` at @object_path, if
+     * any.
+     * @param objectPath - Object path to look up.
+     * @param interfaceName - D-Bus interface name to look up.
+     */
     getInterface(objectPath: string, interfaceName: string): DBusInterface | null;
+    /**
+     * Gets the #GDBusObject at @object_path, if any.
+     * @param objectPath - Object path to look up.
+     */
     getObject(objectPath: string): DBusObject | null;
+    /**
+     * Gets the object path that `manager` is for.
+     */
     getObjectPath(): string;
+    /**
+     * Gets all #GDBusObject objects known to @manager.
+     */
     getObjects(): DBusObject[];
+    /**
+     * 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?: Cancellable | null): boolean;
     connect(signal: "interface-proxy-properties-changed", handler: (self: DBusObjectManagerClient, objectProxy: DBusObjectProxy, interfaceProxy: DBusProxy, changedProperties: GLib.Variant, invalidatedProperties: string[]) => void, after?: boolean): number;
     connect(signal: "interface-proxy-signal", handler: (self: DBusObjectManagerClient, objectProxy: DBusObjectProxy, interfaceProxy: DBusProxy, senderName: string, signalName: string, parameters: GLib.Variant) => void, after?: boolean): number;

package/dist/generated/gio/dbus-object-manager-client.js

@@ -6,6 +6,86 @@ import { DBusObject } from "./dbus-object.js";
 import { DBusObjectProxy } from "./dbus-object-proxy.js";
 import { DBusProxy } from "./dbus-proxy.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GDBusObjectManagerClient` is used to create, monitor and delete object
+ * proxies for remote objects exported by a [class@Gio.DBusObjectManagerServer]
+ * (or any code implementing the
+ * org.freedesktop.DBus.ObjectManager
+ * interface).
+ *
+ * Once an instance of this type has been created, you can connect to
+ * the [signal@Gio.DBusObjectManager::object-added] and
+ * [signal@Gio.DBusObjectManager::object-removed signals] and inspect the
+ * [class@Gio.DBusObjectProxy] objects returned by
+ * [method@Gio.DBusObjectManager.get_objects].
+ *
+ * If the name for a `GDBusObjectManagerClient` is not owned by anyone at
+ * object construction time, the default behavior is to request the
+ * message bus to launch an owner for the name. This behavior can be
+ * disabled using the `G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START`
+ * flag. It’s also worth noting that this only works if the name of
+ * interest is activatable in the first place. E.g. in some cases it
+ * is not possible to launch an owner for the requested name. In this
+ * case, `GDBusObjectManagerClient` object construction still succeeds but
+ * there will be no object proxies
+ * (e.g. [method@Gio.DBusObjectManager.get_objects] returns the empty list) and
+ * the [property@Gio.DBusObjectManagerClient:name-owner] property is `NULL`.
+ *
+ * The owner of the requested name can come and go (for example
+ * consider a system service being restarted) – `GDBusObjectManagerClient`
+ * handles this case too; simply connect to the [signal@GObject.Object::notify]
+ * signal to watch for changes on the
+ * [property@Gio.DBusObjectManagerClient:name-owner] property. When the name
+ * owner vanishes, the behavior is that
+ * [property@Gio.DBusObjectManagerClient:name-owner] is set to `NULL` (this
+ * includes emission of the [signal@GObject.Object::notify] signal) and then
+ * [signal@Gio.DBusObjectManager::object-removed] signals are synthesized
+ * for all currently existing object proxies. Since
+ * [property@Gio.DBusObjectManagerClient:name-owner] is `NULL` when this
+ * happens, you can use this information to disambiguate a synthesized signal
+ * from a genuine signal caused by object removal on the remote
+ * [iface@Gio.DBusObjectManager]. Similarly, when a new name owner appears,
+ * [signal@Gio.DBusObjectManager::object-added] signals are synthesized
+ * while [property@Gio.DBusObjectManagerClient:name-owner] is still `NULL`. Only
+ * when all object proxies have been added, the
+ * [property@Gio.DBusObjectManagerClient:name-owner] is set to the new name
+ * owner (this includes emission of the [signal@GObject.Object::notify] signal).
+ * Furthermore, you are guaranteed that
+ * [property@Gio.DBusObjectManagerClient:name-owner] will alternate between a
+ * name owner (e.g. `:1.42`) and `NULL` even in the case where
+ * the name of interest is atomically replaced
+ *
+ * Ultimately, `GDBusObjectManagerClient` is used to obtain
+ * [class@Gio.DBusProxy] instances. All signals (including the
+ * `org.freedesktop.DBus.Properties::PropertiesChanged` signal)
+ * delivered to [class@Gio.DBusProxy] instances are guaranteed to originate
+ * from the name owner. This guarantee along with the behavior
+ * described above, means that certain race conditions including the
+ * “half the proxy is from the old owner and the other half is from
+ * the new owner” problem cannot happen.
+ *
+ * To avoid having the application connect to signals on the returned
+ * [class@Gio.DBusObjectProxy] and [class@Gio.DBusProxy] objects, the
+ * [signal@Gio.DBusObject::interface-added],
+ * [signal@Gio.DBusObject::interface-removed],
+ * [signal@Gio.DBusProxy::g-properties-changed] and
+ * [signal@Gio.DBusProxy::g-signal] signals
+ * are also emitted on the `GDBusObjectManagerClient` instance managing these
+ * objects. The signals emitted are
+ * [signal@Gio.DBusObjectManager::interface-added],
+ * [signal@Gio.DBusObjectManager::interface-removed],
+ * [signal@Gio.DBusObjectManagerClient::interface-proxy-properties-changed] and
+ * [signal@Gio.DBusObjectManagerClient::interface-proxy-signal].
+ *
+ * Note that all callbacks and signals are emitted in the
+ * thread-default main context (see
+ * [method@GLib.MainContext.push_thread_default]) that the
+ * `GDBusObjectManagerClient` object was constructed in. Additionally, the
+ * [class@Gio.DBusObjectProxy] and [class@Gio.DBusProxy] objects
+ * originating from the `GDBusObjectManagerClient` object will be created in
+ * the same context and, consequently, will deliver signals in the
+ * same main loop.
+ */
 const SIGNAL_META = {
     "interface-proxy-properties-changed": {
         params: [
@@ -39,6 +119,10 @@ export class DBusObjectManagerClient extends GObject.GObject {
     constructor(...args) {
         super(...args);
     }
+    /**
+     * Finishes an operation started with g_dbus_object_manager_client_new_for_bus().
+     * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new_for_bus().
+     */
     static objectManagerClientNewForBusFinish(res) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_object_manager_client_new_for_bus_finish", [
             {
@@ -48,6 +132,22 @@ export class DBusObjectManagerClient extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, DBusObjectManagerClient);
     }
+    /**
+     * Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead
+     * of a #GDBusConnection.
+     *
+     * This is a synchronous failable constructor - the calling thread is
+     * blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
+     * for the asynchronous version.
+     * @param busType - A #GBusType.
+     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+     * @param name - The owner of the control object (unique or well-known name).
+     * @param objectPath - The object path of the control object.
+     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
+     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
+     * @param cancellable - A #GCancellable or %NULL
+     */
     static objectManagerClientNewForBusSync(busType, flags, name, objectPath, getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, cancellable) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_object_manager_client_new_for_bus_sync", [
             {
@@ -89,6 +189,21 @@ export class DBusObjectManagerClient extends GObject.GObject {
         ], { type: "gobject", borrowed: false });
         return getObject(ptr, DBusObjectManagerClient);
     }
+    /**
+     * Creates a new #GDBusObjectManagerClient object.
+     *
+     * This is a synchronous failable constructor - the calling thread is
+     * blocked until a reply is received. See g_dbus_object_manager_client_new()
+     * for the asynchronous version.
+     * @param connection - A #GDBusConnection.
+     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+     * @param name - The owner of the control object (unique or well-known name), or %NULL when not using a message bus connection.
+     * @param objectPath - The object path of the control object.
+     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
+     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
+     * @param cancellable - A #GCancellable or %NULL
+     */
     static objectManagerClientNewSync(connection, flags, objectPath, name, getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, cancellable) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_object_manager_client_new_sync", [
             {
@@ -140,6 +255,26 @@ export class DBusObjectManagerClient extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Asynchronously creates a new #GDBusObjectManagerClient object.
+     *
+     * This is an asynchronous failable constructor. When the result is
+     * ready, `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_object_manager_client_new_finish() to get the result. See
+     * g_dbus_object_manager_client_new_sync() for the synchronous version.
+     * @param connection - A #GDBusConnection.
+     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+     * @param name - The owner of the control object (unique or well-known name).
+     * @param objectPath - The object path of the control object.
+     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
+     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
+     * @param cancellable - A #GCancellable or %NULL
+     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied.
+     * @param userData - The data to pass to @callback.
+     */
     static _new(connection, flags, name, objectPath, getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_dbus_object_manager_client_new", [
             {
@@ -190,6 +325,27 @@ export class DBusObjectManagerClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a
+     * #GDBusConnection.
+     *
+     * This is an asynchronous failable constructor. When the result is
+     * ready, `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_object_manager_client_new_for_bus_finish() to get the result. See
+     * g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
+     * @param busType - A #GBusType.
+     * @param flags - Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+     * @param name - The owner of the control object (unique or well-known name).
+     * @param objectPath - The object path of the control object.
+     * @param getProxyTypeFunc - A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+     * @param getProxyTypeUserData - User data to pass to @get_proxy_type_func.
+     * @param getProxyTypeDestroyNotify - Free function for `get_proxy_type_user_data` or %NULL.
+     * @param cancellable - A #GCancellable or %NULL
+     * @param callback - A #GAsyncReadyCallback to call when the request is satisfied.
+     * @param userData - The data to pass to @callback.
+     */
     static newForBus(busType, flags, name, objectPath, getProxyTypeFunc, getProxyTypeUserData, getProxyTypeDestroyNotify, cancellable, callback, userData) {
         call("libgio-2.0.so.0", "g_dbus_object_manager_client_new_for_bus", [
             {
@@ -240,6 +396,9 @@ export class DBusObjectManagerClient extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the #GDBusConnection used by @manager.
+     */
     getConnection() {
         const ptr = call("libgio-2.0.so.0", "g_dbus_object_manager_client_get_connection", [
             {
@@ -249,6 +408,9 @@ export class DBusObjectManagerClient extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, DBusConnection);
     }
+    /**
+     * Gets the flags that `manager` was constructed with.
+     */
     getFlags() {
         return call("libgio-2.0.so.0", "g_dbus_object_manager_client_get_flags", [
             {
@@ -257,6 +419,10 @@ export class DBusObjectManagerClient extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the name that `manager` is for, or %NULL if not a message bus
+     * connection.
+     */
     getName() {
         return call("libgio-2.0.so.0", "g_dbus_object_manager_client_get_name", [
             {
@@ -265,6 +431,12 @@ export class DBusObjectManagerClient extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * The unique name that owns the name that `manager` is for or %NULL if
+     * no-one currently owns that name. You can connect to the
+     * #GObject::notify signal to track changes to the
+     * #GDBusObjectManagerClient:name-owner property.
+     */
     getNameOwner() {
         return call("libgio-2.0.so.0", "g_dbus_object_manager_client_get_name_owner", [
             {
@@ -273,6 +445,48 @@ export class DBusObjectManagerClient extends GObject.GObject {
             },
         ], { type: "string" });
     }
+    /**
+     * 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", [
             {
@@ -300,6 +514,11 @@ export class DBusObjectManagerClient 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", [
@@ -328,6 +547,11 @@ export class DBusObjectManagerClient 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", [
@@ -356,6 +580,12 @@ export class DBusObjectManagerClient extends GObject.GObject {
         }
         return getObject(ptr, GObject.GObject);
     }
+    /**
+     * Gets the interface proxy for `interface_name` at @object_path, if
+     * any.
+     * @param objectPath - Object path to look up.
+     * @param interfaceName - D-Bus interface name to look up.
+     */
     getInterface(objectPath, interfaceName) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_object_manager_get_interface", [
             {
@@ -375,6 +605,10 @@ export class DBusObjectManagerClient extends GObject.GObject {
             return null;
         return getObject(ptr, DBusInterface);
     }
+    /**
+     * Gets the #GDBusObject at @object_path, if any.
+     * @param objectPath - Object path to look up.
+     */
     getObject(objectPath) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_object_manager_get_object", [
             {
@@ -390,6 +624,9 @@ export class DBusObjectManagerClient extends GObject.GObject {
             return null;
         return getObject(ptr, DBusObject);
     }
+    /**
+     * Gets the object path that `manager` is for.
+     */
     getObjectPath() {
         return call("libgio-2.0.so.0", "g_dbus_object_manager_get_object_path", [
             {
@@ -398,6 +635,9 @@ export class DBusObjectManagerClient extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets all #GDBusObject objects known to @manager.
+     */
     getObjects() {
         const ptrs = call("libgio-2.0.so.0", "g_dbus_object_manager_get_objects", [
             {
@@ -412,6 +652,47 @@ export class DBusObjectManagerClient extends GObject.GObject {
         });
         return ptrs.map((ptr) => getObject(ptr, DBusObject));
     }
+    /**
+     * 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", [