@gtkx/ffi 0.1.45 → 0.1.47

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

@@ -4,15 +4,105 @@ import { DBusAuthObserver } from "./dbus-auth-observer.js";
 import { DBusConnection } from "./dbus-connection.js";
 import * as GObject from "../gobject/index.js";
 export declare class DBusServer extends GObject.GObject {
+    /**
+     * Creates a new D-Bus server that listens on the first address in
+     * `address` that works.
+     *
+     * Once constructed, you can use g_dbus_server_get_client_address() to
+     * get a D-Bus address string that clients can use to connect.
+     *
+     * To have control over the available authentication mechanisms and
+     * the users that are authorized to connect, it is strongly recommended
+     * to provide a non-%NULL #GDBusAuthObserver.
+     *
+     * Connect to the #GDBusServer::new-connection signal to handle
+     * incoming connections.
+     *
+     * The returned #GDBusServer isn't active - you have to start it with
+     * g_dbus_server_start().
+     *
+     * #GDBusServer is used in this [example](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-peer.c).
+     *
+     * This is a synchronous failable constructor. There is currently no
+     * asynchronous version.
+     * @param address - A D-Bus address.
+     * @param flags - Flags from the #GDBusServerFlags enumeration.
+     * @param guid - A D-Bus GUID.
+     * @param observer - A #GDBusAuthObserver or %NULL.
+     * @param cancellable - A #GCancellable or %NULL.
+     */
     constructor(address: string, flags: DBusServerFlags, guid: string, observer?: DBusAuthObserver | null, cancellable?: Cancellable | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets a
+     * D-Bus address
+     * string that can be used by clients to connect to @server.
+     *
+     * This is valid and non-empty if initializing the #GDBusServer succeeded.
+     */
     getClientAddress(): string;
+    /**
+     * Gets the flags for @server.
+     */
     getFlags(): DBusServerFlags;
+    /**
+     * Gets the GUID for @server, as provided to g_dbus_server_new_sync().
+     */
     getGuid(): string;
+    /**
+     * Gets whether `server` is active.
+     */
     isActive(): boolean;
+    /**
+     * Starts @server.
+     */
     start(): void;
+    /**
+     * Stops @server.
+     */
     stop(): 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: "new-connection", handler: (self: DBusServer, connection: DBusConnection) => boolean, after?: boolean): number;
     connect(signal: "notify", handler: (self: DBusServer, pspec: GObject.ParamSpec) => void, after?: boolean): number;

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

@@ -2,6 +2,28 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { DBusConnection } from "./dbus-connection.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GDBusServer` is a helper for listening to and accepting D-Bus
+ * connections. This can be used to create a new D-Bus server, allowing two
+ * peers to use the D-Bus protocol for their own specialized communication.
+ * A server instance provided in this way will not perform message routing or
+ * implement the
+ * `org.freedesktop.DBus` interface.
+ *
+ * To just export an object on a well-known name on a message bus, such as the
+ * session or system bus, you should instead use [func@Gio.bus_own_name].
+ *
+ * An example of peer-to-peer communication with GDBus can be found
+ * in [gdbus-example-peer.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-peer.c).
+ *
+ * Note that a minimal `GDBusServer` will accept connections from any
+ * peer. In many use-cases it will be necessary to add a
+ * [class@Gio.DBusAuthObserver] that only accepts connections that have
+ * successfully authenticated as the same user that is running the
+ * `GDBusServer`. Since GLib 2.68 this can be achieved more simply by passing
+ * the `G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER` flag to the
+ * server.
+ */
 const SIGNAL_META = {
     "new-connection": {
         params: [
@@ -44,6 +66,13 @@ export class DBusServer extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets a
+     * D-Bus address
+     * string that can be used by clients to connect to @server.
+     *
+     * This is valid and non-empty if initializing the #GDBusServer succeeded.
+     */
     getClientAddress() {
         return call("libgio-2.0.so.0", "g_dbus_server_get_client_address", [
             {
@@ -52,6 +81,9 @@ export class DBusServer extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the flags for @server.
+     */
     getFlags() {
         return call("libgio-2.0.so.0", "g_dbus_server_get_flags", [
             {
@@ -60,6 +92,9 @@ export class DBusServer extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the GUID for @server, as provided to g_dbus_server_new_sync().
+     */
     getGuid() {
         return call("libgio-2.0.so.0", "g_dbus_server_get_guid", [
             {
@@ -68,6 +103,9 @@ export class DBusServer extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets whether `server` is active.
+     */
     isActive() {
         return call("libgio-2.0.so.0", "g_dbus_server_is_active", [
             {
@@ -76,6 +114,9 @@ export class DBusServer extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Starts @server.
+     */
     start() {
         call("libgio-2.0.so.0", "g_dbus_server_start", [
             {
@@ -84,6 +125,9 @@ export class DBusServer extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Stops @server.
+     */
     stop() {
         call("libgio-2.0.so.0", "g_dbus_server_stop", [
             {
@@ -92,6 +136,47 @@ export class DBusServer 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", [

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

@@ -3,15 +3,33 @@ import { DBusArgInfo } from "./dbus-arg-info.js";
 export interface DBusSignalInfoInit {
     refCount?: number;
 }
+/** Information about a signal on a D-Bus interface. */
 export declare class DBusSignalInfo {
     ptr: unknown;
     constructor(init?: DBusSignalInfoInit);
     protected createPtr(init: DBusSignalInfoInit): unknown;
+    /**
+     * If `info` is statically allocated does nothing. Otherwise increases
+     * the reference count.
+     */
     ref(): DBusSignalInfo;
+    /**
+     * 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 signal, e.g. "NameOwnerChanged". */
     get name(): string;
+    /**
+     * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no arguments.
+     */
     get args(): DBusArgInfo[];
+    /**
+     * 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-signal-info.js

@@ -1,5 +1,6 @@
 import { alloc, call, read, write } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/** Information about a signal on a D-Bus interface. */
 export class DBusSignalInfo {
     ptr;
     constructor(init = {}) {
@@ -11,6 +12,10 @@ export class DBusSignalInfo {
             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_signal_info_ref", [
             {
@@ -25,6 +30,11 @@ export class DBusSignalInfo {
         });
         return getObject(ptr, DBusSignalInfo);
     }
+    /**
+     * 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_signal_info_unref", [
             {
@@ -33,15 +43,20 @@ export class DBusSignalInfo {
             },
         ], { 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 signal, e.g. "NameOwnerChanged". */
     get name() {
         return read(this.ptr, { type: "string" }, 8);
     }
+    /**
+     * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no arguments.
+     */
     get args() {
         return read(this.ptr, {
             type: "array",
@@ -52,6 +67,9 @@ export class DBusSignalInfo {
             },
         }, 16);
     }
+    /**
+     * 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/debug-controller-dbus.d.ts

@@ -3,12 +3,89 @@ import { DBusConnection } from "./dbus-connection.js";
 import { DBusMethodInvocation } from "./dbus-method-invocation.js";
 import * as GObject from "../gobject/index.js";
 export declare class DebugControllerDBus extends GObject.GObject {
+    /**
+     * Create a new #GDebugControllerDBus and synchronously initialize it.
+     *
+     * Initializing the object will export the debug object on @connection. The
+     * object will remain registered until the last reference to the
+     * #GDebugControllerDBus is dropped.
+     *
+     * Initialization may fail if registering the object on `connection` fails.
+     * @param connection - a #GDBusConnection to register the debug object on
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     constructor(connection: DBusConnection, cancellable?: Cancellable | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Stop the debug controller, unregistering its object from the bus.
+     *
+     * Any pending method calls to the object will complete successfully, but new
+     * ones will return an error. This method will block until all pending
+     * #GDebugControllerDBus::authorize signals have been handled. This is expected
+     * to not take long, as it will just be waiting for threads to join. If any
+     * #GDebugControllerDBus::authorize signal handlers are still executing in other
+     * threads, this will block until after they have returned.
+     *
+     * This method will be called automatically when the final reference to the
+     * #GDebugControllerDBus is dropped. You may want to call it explicitly to know
+     * when the controller has been fully removed from the bus, or to break
+     * reference count cycles.
+     *
+     * Calling this method from within a #GDebugControllerDBus::authorize signal
+     * handler will cause a deadlock and must not be done.
+     */
     stop(): void;
+    /**
+     * Get the value of #GDebugController:debug-enabled.
+     */
     getDebugEnabled(): boolean;
+    /**
+     * Set the value of #GDebugController:debug-enabled.
+     * @param debugEnabled - %TRUE if debug output should be exposed, %FALSE otherwise
+     */
     setDebugEnabled(debugEnabled: boolean): 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: "authorize", handler: (self: DebugControllerDBus, invocation: DBusMethodInvocation) => boolean, after?: boolean): number;
     connect(signal: "notify", handler: (self: DebugControllerDBus, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/gio/debug-controller-dbus.js

@@ -2,6 +2,118 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { DBusMethodInvocation } from "./dbus-method-invocation.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GDebugControllerDBus` is an implementation of [iface@Gio.DebugController]
+ * which exposes debug settings as a D-Bus object.
+ *
+ * It is a [iface@Gio.Initable] object, and will register an object at
+ * `/org/gtk/Debugging` on the bus given as
+ * [property@Gio.DebugControllerDBus:connection] once it’s initialized. The
+ * object will be unregistered when the last reference to the
+ * `GDebugControllerDBus` is dropped.
+ *
+ * This D-Bus object can be used by remote processes to enable or disable debug
+ * output in this process. Remote processes calling
+ * `org.gtk.Debugging.SetDebugEnabled()` will affect the value of
+ * [property@Gio.DebugController:debug-enabled] and, by default,
+ * [func@GLib.log_get_debug_enabled].
+ *
+ * By default, no processes are allowed to call `SetDebugEnabled()` unless a
+ * [signal@Gio.DebugControllerDBus::authorize] signal handler is installed. This
+ * is because the process may be privileged, or might expose sensitive
+ * information in its debug output. You may want to restrict the ability to
+ * enable debug output to privileged users or processes.
+ *
+ * One option is to install a D-Bus security policy which restricts access to
+ * `SetDebugEnabled()`, installing something like the following in
+ * `$datadir/dbus-1/system.d/`:
+ *
+ * ```xml
+ * <?xml version="1.0"?> <!--*-nxml-*-->
+ * <!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ * "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+ * <busconfig>
+ * <policy user="root">
+ * <allow send_destination="com.example.MyService" send_interface="org.gtk.Debugging"/>
+ * </policy>
+ * <policy context="default">
+ * <deny send_destination="com.example.MyService" send_interface="org.gtk.Debugging"/>
+ * </policy>
+ * </busconfig>
+ * ```
+ *
+ * This will prevent the `SetDebugEnabled()` method from being called by all
+ * except root. It will not prevent the `DebugEnabled` property from being read,
+ * as it’s accessed through the `org.freedesktop.DBus.Properties` interface.
+ *
+ * Another option is to use polkit to allow or deny requests on a case-by-case
+ * basis, allowing for the possibility of dynamic authorisation. To do this,
+ * connect to the [signal@Gio.DebugControllerDBus::authorize] signal and query
+ * polkit in it:
+ *
+ * ```c
+ * g_autoptr(GError) child_error = NULL;
+ * g_autoptr(GDBusConnection) connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
+ * gulong debug_controller_authorize_id = 0;
+ *
+ * // Set up the debug controller.
+ * debug_controller = G_DEBUG_CONTROLLER (g_debug_controller_dbus_new (priv->connection, NULL, &child_error));
+ * if (debug_controller == NULL)
+ * {
+ * g_error ("Could not register debug controller on bus: %s",
+ * child_error->message);
+ * }
+ *
+ * debug_controller_authorize_id = g_signal_connect (debug_controller,
+ * "authorize",
+ * G_CALLBACK (debug_controller_authorize_cb),
+ * self);
+ *
+ * static gboolean
+ * debug_controller_authorize_cb (GDebugControllerDBus  *debug_controller,
+ * GDBusMethodInvocation *invocation,
+ * gpointer               user_data)
+ * {
+ * g_autoptr(PolkitAuthority) authority = NULL;
+ * g_autoptr(PolkitSubject) subject = NULL;
+ * g_autoptr(PolkitAuthorizationResult) auth_result = NULL;
+ * g_autoptr(GError) local_error = NULL;
+ * GDBusMessage *message;
+ * GDBusMessageFlags message_flags;
+ * PolkitCheckAuthorizationFlags flags = POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE;
+ *
+ * message = g_dbus_method_invocation_get_message (invocation);
+ * message_flags = g_dbus_message_get_flags (message);
+ *
+ * authority = polkit_authority_get_sync (NULL, &local_error);
+ * if (authority == NULL)
+ * {
+ * g_warning ("Failed to get polkit authority: %s", local_error->message);
+ * return FALSE;
+ * }
+ *
+ * if (message_flags & G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION)
+ * flags |= POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION;
+ *
+ * subject = polkit_system_bus_name_new (g_dbus_method_invocation_get_sender (invocation));
+ *
+ * auth_result = polkit_authority_check_authorization_sync (authority,
+ * subject,
+ * "com.example.MyService.set-debug-enabled",
+ * NULL,
+ * flags,
+ * NULL,
+ * &local_error);
+ * if (auth_result == NULL)
+ * {
+ * g_warning ("Failed to get check polkit authorization: %s", local_error->message);
+ * return FALSE;
+ * }
+ *
+ * return polkit_authorization_result_get_is_authorized (auth_result);
+ * }
+ * ```
+ */
 const SIGNAL_META = {
     authorize: {
         params: [
@@ -31,6 +143,24 @@ export class DebugControllerDBus extends GObject.GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Stop the debug controller, unregistering its object from the bus.
+     *
+     * Any pending method calls to the object will complete successfully, but new
+     * ones will return an error. This method will block until all pending
+     * #GDebugControllerDBus::authorize signals have been handled. This is expected
+     * to not take long, as it will just be waiting for threads to join. If any
+     * #GDebugControllerDBus::authorize signal handlers are still executing in other
+     * threads, this will block until after they have returned.
+     *
+     * This method will be called automatically when the final reference to the
+     * #GDebugControllerDBus is dropped. You may want to call it explicitly to know
+     * when the controller has been fully removed from the bus, or to break
+     * reference count cycles.
+     *
+     * Calling this method from within a #GDebugControllerDBus::authorize signal
+     * handler will cause a deadlock and must not be done.
+     */
     stop() {
         call("libgio-2.0.so.0", "g_debug_controller_dbus_stop", [
             {
@@ -39,6 +169,9 @@ export class DebugControllerDBus extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Get the value of #GDebugController:debug-enabled.
+     */
     getDebugEnabled() {
         return call("libgio-2.0.so.0", "g_debug_controller_get_debug_enabled", [
             {
@@ -47,6 +180,10 @@ export class DebugControllerDBus extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Set the value of #GDebugController:debug-enabled.
+     * @param debugEnabled - %TRUE if debug output should be exposed, %FALSE otherwise
+     */
     setDebugEnabled(debugEnabled) {
         call("libgio-2.0.so.0", "g_debug_controller_set_debug_enabled", [
             {
@@ -59,6 +196,47 @@ export class DebugControllerDBus 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", [

package/dist/generated/gio/debug-controller.d.ts

@@ -1,7 +1,32 @@
+/**
+ * `GDebugController` is an interface to expose control of debugging features and
+ * debug output.
+ *
+ * It is implemented on Linux using [class@Gio.DebugControllerDBus], which
+ * exposes a D-Bus interface to allow authenticated peers to control debug
+ * features in this process.
+ *
+ * Whether debug output is enabled is exposed as
+ * [property@Gio.DebugController:debug-enabled]. This controls
+ * [func@GLib.log_set_debug_enabled] by default. Application code may
+ * connect to the [signal@GObject.Object::notify] signal for it
+ * to control other parts of its debug infrastructure as necessary.
+ *
+ * If your application or service is using the default GLib log writer function,
+ * creating one of the built-in implementations of `GDebugController` should be
+ * all that’s needed to dynamically enable or disable debug output.
+ */
 export declare class DebugController {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): DebugController;
+    /**
+     * Get the value of #GDebugController:debug-enabled.
+     */
     getDebugEnabled(): boolean;
+    /**
+     * Set the value of #GDebugController:debug-enabled.
+     * @param debugEnabled - %TRUE if debug output should be exposed, %FALSE otherwise
+     */
     setDebugEnabled(debugEnabled: boolean): void;
 }