@gtkx/ffi 0.1.44 → 0.1.46

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

@@ -1,6 +1,12 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { DBusInterface } from "./dbus-interface.js";
+/**
+ * The `GDBusObject` type is the base type for D-Bus objects on both
+ * the service side (see [class@Gio.DBusObjectSkeleton]) and the client side
+ * (see [class@Gio.DBusObjectProxy]). It is essentially just a container of
+ * interfaces.
+ */
 export class DBusObject {
     ptr;
     constructor(ptr) {
@@ -9,6 +15,11 @@ export class DBusObject {
     static fromPtr(ptr) {
         return new DBusObject(ptr);
     }
+    /**
+     * Gets the D-Bus interface with name `interface_name` associated with
+     * @object, if any.
+     * @param interfaceName - A D-Bus interface name.
+     */
     getInterface(interfaceName) {
         const ptr = call("libgio-2.0.so.0", "g_dbus_object_get_interface", [
             {
@@ -24,6 +35,9 @@ export class DBusObject {
             return null;
         return getObject(ptr, DBusInterface);
     }
+    /**
+     * Gets the D-Bus interfaces associated with @object.
+     */
     getInterfaces() {
         const ptrs = call("libgio-2.0.so.0", "g_dbus_object_get_interfaces", [
             {
@@ -38,6 +52,9 @@ export class DBusObject {
         });
         return ptrs.map((ptr) => getObject(ptr, DBusInterface));
     }
+    /**
+     * Gets the object path for @object.
+     */
     getObjectPath() {
         return call("libgio-2.0.so.0", "g_dbus_object_get_object_path", [
             {

package/dist/generated/gio/dbus-property-info.d.ts

@@ -3,16 +3,33 @@ import { DBusAnnotationInfo } from "./dbus-annotation-info.js";
 export interface DBusPropertyInfoInit {
     refCount?: number;
 }
+/** Information about a D-Bus property on a D-Bus interface. */
 export declare class DBusPropertyInfo {
     ptr: unknown;
     constructor(init?: DBusPropertyInfoInit);
     protected createPtr(init: DBusPropertyInfoInit): unknown;
+    /**
+     * If `info` is statically allocated does nothing. Otherwise increases
+     * the reference count.
+     */
     ref(): DBusPropertyInfo;
+    /**
+     * If `info` is statically allocated, does nothing. Otherwise decreases
+     * the reference count of @info. When its reference count drops to 0,
+     * the memory used is freed.
+     */
     unref(): void;
+    /** The reference count or -1 if statically allocated. */
     get refCount(): number;
     set refCount(value: number);
+    /** The name of the D-Bus property, e.g. "SupportedFilesystems". */
     get name(): string;
+    /** The D-Bus signature of the property (a single complete type). */
     get signature(): string;
+    /** Access control flags for the property. */
     get flags(): DBusPropertyInfoFlags;
+    /**
+     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
+     */
     get annotations(): DBusAnnotationInfo[];
 }

package/dist/generated/gio/dbus-property-info.js

@@ -1,5 +1,6 @@
 import { alloc, call, read, write } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/** Information about a D-Bus property on a D-Bus interface. */
 export class DBusPropertyInfo {
     ptr;
     constructor(init = {}) {
@@ -11,6 +12,10 @@ export class DBusPropertyInfo {
             write(ptr, { type: "int", size: 32, unsigned: false }, 0, init.refCount);
         return ptr;
     }
+    /**
+     * If `info` is statically allocated does nothing. Otherwise increases
+     * the reference count.
+     */
     ref() {
         const ptr = call("libgio-2.0.so.0", "g_dbus_property_info_ref", [
             {
@@ -25,6 +30,11 @@ export class DBusPropertyInfo {
         });
         return getObject(ptr, DBusPropertyInfo);
     }
+    /**
+     * If `info` is statically allocated, does nothing. Otherwise decreases
+     * the reference count of @info. When its reference count drops to 0,
+     * the memory used is freed.
+     */
     unref() {
         call("libgio-2.0.so.0", "g_dbus_property_info_unref", [
             {
@@ -33,21 +43,28 @@ export class DBusPropertyInfo {
             },
         ], { type: "undefined" });
     }
+    /** The reference count or -1 if statically allocated. */
     get refCount() {
         return read(this.ptr, { type: "int", size: 32, unsigned: false }, 0);
     }
     set refCount(value) {
         write(this.ptr, { type: "int", size: 32, unsigned: false }, 0, value);
     }
+    /** The name of the D-Bus property, e.g. "SupportedFilesystems". */
     get name() {
         return read(this.ptr, { type: "string" }, 8);
     }
+    /** The D-Bus signature of the property (a single complete type). */
     get signature() {
         return read(this.ptr, { type: "string" }, 16);
     }
+    /** Access control flags for the property. */
     get flags() {
         return read(this.ptr, { type: "int", size: 32, unsigned: false }, 24);
     }
+    /**
+     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
+     */
     get annotations() {
         return read(this.ptr, {
             type: "array",

package/dist/generated/gio/dbus-proxy.d.ts

@@ -9,39 +9,473 @@ import { UnixFDList } from "./unix-fdlist.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 export declare class DBusProxy extends GObject.GObject {
+    /**
+     * Finishes creating a #GDBusProxy.
+     * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new().
+     */
     constructor(res: AsyncResult);
     constructor(...args: unknown[]);
+    /**
+     * Finishes creating a #GDBusProxy.
+     * @param res - A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new_for_bus().
+     */
     static proxyNewForBusFinish(res: AsyncResult): 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: BusType, flags: DBusProxyFlags, name: string, objectPath: string, interfaceName: string, info?: DBusInterfaceInfo | null, cancellable?: Cancellable | null): 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: DBusConnection, flags: DBusProxyFlags, objectPath: string, interfaceName: string, info?: DBusInterfaceInfo | null, name?: string | null, cancellable?: Cancellable | null): DBusProxy;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * 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: DBusConnection, flags: DBusProxyFlags, objectPath: string, interfaceName: string, info?: DBusInterfaceInfo | null, name?: string | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * 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: BusType, flags: DBusProxyFlags, name: string, objectPath: string, interfaceName: string, info?: DBusInterfaceInfo | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * 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: string, flags: DBusCallFlags, timeoutMsec: number, parameters?: GLib.Variant | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * 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: AsyncResult): 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: string, flags: DBusCallFlags, timeoutMsec: number, parameters?: GLib.Variant | null, cancellable?: Cancellable | null): 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: string, flags: DBusCallFlags, timeoutMsec: number, parameters?: GLib.Variant | null, fdList?: UnixFDList | null, cancellable?: Cancellable | null, callback?: (...args: unknown[]) => unknown | null, userData?: number | null): void;
+    /**
+     * 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: AsyncResult, outFdList?: Ref<UnixFDList> | null): 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: string, flags: DBusCallFlags, timeoutMsec: number, parameters?: GLib.Variant | null, fdList?: UnixFDList | null, outFdList?: Ref<UnixFDList> | null, cancellable?: Cancellable | null): 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: string): GLib.Variant | null;
+    /**
+     * Gets the names of all cached properties on @proxy.
+     */
     getCachedPropertyNames(): string[] | null;
+    /**
+     * Gets the connection `proxy` is for.
+     */
     getConnection(): 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(): number;
+    /**
+     * Gets the flags that `proxy` was constructed with.
+     */
     getFlags(): DBusProxyFlags;
+    /**
+     * Returns the #GDBusInterfaceInfo, if any, specifying the interface
+     * that `proxy` conforms to. See the #GDBusProxy:g-interface-info
+     * property for more details.
+     */
     getInterfaceInfo(): DBusInterfaceInfo | null;
+    /**
+     * Gets the D-Bus interface name `proxy` is for.
+     */
     getInterfaceName(): string;
+    /**
+     * 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(): string | null;
+    /**
+     * 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(): string | null;
+    /**
+     * Gets the object path `proxy` is for.
+     */
     getObjectPath(): string;
+    /**
+     * 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: string, value?: GLib.Variant | null): void;
+    /**
+     * 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: number): void;
+    /**
+     * 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?: DBusInterfaceInfo | null): void;
+    /**
+     * 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 #GDBusObject that `interface_` belongs to, if any.
+     */
     dupObject(): DBusObject | null;
+    /**
+     * Gets D-Bus introspection information for the D-Bus interface
+     * implemented by @interface_.
+     */
     getInfo(): 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?: DBusObject | null): void;
+    /**
+     * 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: "g-properties-changed", handler: (self: DBusProxy, changedProperties: GLib.Variant, invalidatedProperties: string[]) => void, after?: boolean): number;
     connect(signal: "g-signal", handler: (self: DBusProxy, senderName: string, signalName: string, parameters: GLib.Variant) => void, after?: boolean): number;