@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gobject/signal-group.d.ts

@@ -3,15 +3,72 @@ import { Closure } from "./closure.js";
 import { ParamSpec } from "./param-spec.js";
 import { GObject } from "./object.js";
 export declare class SignalGroup extends GObject {
+    /**
+     * Creates a new #GSignalGroup for target instances of @target_type.
+     * @param targetType - the #GType of the target instance.
+     */
     constructor(targetType: number);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Blocks all signal handlers managed by `self` so they will not
+     * be called during any signal emissions. Must be unblocked exactly
+     * the same number of times it has been blocked to become active again.
+     *
+     * This blocked state will be kept across changes of the target instance.
+     */
     block(): void;
+    /**
+     * Connects `closure` to the signal `detailed_signal` on #GSignalGroup:target.
+     *
+     * You cannot connect a signal handler after #GSignalGroup:target has been set.
+     * @param detailedSignal - a string of the form `signal-name` with optional `::signal-detail`
+     * @param closure - the closure to connect.
+     * @param after - whether the handler should be called before or after the
+     */
     connectClosure(detailedSignal: string, closure: Closure, after: boolean): void;
+    /**
+     * Connects `c_handler` to the signal `detailed_signal` on the target instance of @self.
+     *
+     * You cannot connect a signal handler after #GSignalGroup:target has been set.
+     * @param detailedSignal - a string of the form "signal-name::detail"
+     * @param cHandler - the #GCallback to connect
+     * @param data - the data to pass to `c_handler` calls
+     * @param notify - function to be called when disposing of @self
+     * @param flags - the flags used to create the signal connection
+     */
     connectData(detailedSignal: string, cHandler: (...args: unknown[]) => unknown, notify: (...args: unknown[]) => unknown, flags: ConnectFlags, data?: number | null): void;
+    /**
+     * Connects `c_handler` to the signal `detailed_signal` on the target instance of @self.
+     *
+     * The instance on which the signal is emitted and `data` will be swapped when calling @c_handler.
+     *
+     * You cannot connect a signal handler after #GSignalGroup:target has been set.
+     * @param detailedSignal - a string of the form "signal-name::detail"
+     * @param cHandler - the #GCallback to connect
+     * @param data - the data to pass to `c_handler` calls
+     */
     connectSwapped(detailedSignal: string, cHandler: (...args: unknown[]) => unknown, data?: number | null): void;
+    /**
+     * Gets the target instance used when connecting signals.
+     */
     dupTarget(): GObject | null;
+    /**
+     * Sets the target instance used when connecting signals. Any signal
+     * that has been registered with g_signal_group_connect_object() or
+     * similar functions will be connected to this object.
+     *
+     * If the target instance was previously set, signals will be
+     * disconnected from that object prior to connecting to @target.
+     * @param target - The target instance used
+     */
     setTarget(target?: GObject | null): void;
+    /**
+     * Unblocks all signal handlers managed by `self` so they will be
+     * called again during any signal emissions unless it is blocked
+     * again. Must be unblocked exactly the same number of times it
+     * has been blocked to become active again.
+     */
     unblock(): void;
     connect(signal: "bind", handler: (self: SignalGroup, instance: GObject) => void, after?: boolean): number;
     connect(signal: "unbind", handler: (self: SignalGroup) => void, after?: boolean): number;

package/dist/generated/gobject/signal-group.js

@@ -2,6 +2,27 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { ParamSpec } from "./param-spec.js";
 import { GObject } from "./object.js";
+/**
+ * `GSignalGroup` manages a collection of signals on a `GObject`.
+ *
+ * `GSignalGroup` simplifies the process of connecting  many signals to a `GObject`
+ * as a group. As such there is no API to disconnect a signal from the group.
+ *
+ * In particular, this allows you to:
+ *
+ * - Change the target instance, which automatically causes disconnection
+ * of the signals from the old instance and connecting to the new instance.
+ * - Block and unblock signals as a group
+ * - Ensuring that blocked state transfers across target instances.
+ *
+ * One place you might want to use such a structure is with `GtkTextView` and
+ * `GtkTextBuffer`. Often times, you'll need to connect to many signals on
+ * `GtkTextBuffer` from a `GtkTextView` subclass. This allows you to create a
+ * signal group during instance construction, simply bind the
+ * `GtkTextView:buffer` property to `GSignalGroup:target` and connect
+ * all the signals you need. When the `GtkTextView:buffer` property changes
+ * all of the signals will be transitioned correctly.
+ */
 const SIGNAL_META = {
     bind: {
         params: [
@@ -30,6 +51,13 @@ export class SignalGroup extends GObject {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Blocks all signal handlers managed by `self` so they will not
+     * be called during any signal emissions. Must be unblocked exactly
+     * the same number of times it has been blocked to become active again.
+     *
+     * This blocked state will be kept across changes of the target instance.
+     */
     block() {
         call("libgobject-2.0.so.0", "g_signal_group_block", [
             {
@@ -38,6 +66,14 @@ export class SignalGroup extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Connects `closure` to the signal `detailed_signal` on #GSignalGroup:target.
+     *
+     * You cannot connect a signal handler after #GSignalGroup:target has been set.
+     * @param detailedSignal - a string of the form `signal-name` with optional `::signal-detail`
+     * @param closure - the closure to connect.
+     * @param after - whether the handler should be called before or after the
+     */
     connectClosure(detailedSignal, closure, after) {
         call("libgobject-2.0.so.0", "g_signal_group_connect_closure", [
             {
@@ -63,6 +99,16 @@ export class SignalGroup extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Connects `c_handler` to the signal `detailed_signal` on the target instance of @self.
+     *
+     * You cannot connect a signal handler after #GSignalGroup:target has been set.
+     * @param detailedSignal - a string of the form "signal-name::detail"
+     * @param cHandler - the #GCallback to connect
+     * @param data - the data to pass to `c_handler` calls
+     * @param notify - function to be called when disposing of @self
+     * @param flags - the flags used to create the signal connection
+     */
     connectData(detailedSignal, cHandler, notify, flags, data) {
         call("libgobject-2.0.so.0", "g_signal_group_connect_data", [
             {
@@ -92,6 +138,16 @@ export class SignalGroup extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Connects `c_handler` to the signal `detailed_signal` on the target instance of @self.
+     *
+     * The instance on which the signal is emitted and `data` will be swapped when calling @c_handler.
+     *
+     * You cannot connect a signal handler after #GSignalGroup:target has been set.
+     * @param detailedSignal - a string of the form "signal-name::detail"
+     * @param cHandler - the #GCallback to connect
+     * @param data - the data to pass to `c_handler` calls
+     */
     connectSwapped(detailedSignal, cHandler, data) {
         call("libgobject-2.0.so.0", "g_signal_group_connect_swapped", [
             {
@@ -113,6 +169,9 @@ export class SignalGroup extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the target instance used when connecting signals.
+     */
     dupTarget() {
         const ptr = call("libgobject-2.0.so.0", "g_signal_group_dup_target", [
             {
@@ -124,6 +183,15 @@ export class SignalGroup extends GObject {
             return null;
         return getObject(ptr, GObject);
     }
+    /**
+     * Sets the target instance used when connecting signals. Any signal
+     * that has been registered with g_signal_group_connect_object() or
+     * similar functions will be connected to this object.
+     *
+     * If the target instance was previously set, signals will be
+     * disconnected from that object prior to connecting to @target.
+     * @param target - The target instance used
+     */
     setTarget(target) {
         call("libgobject-2.0.so.0", "g_signal_group_set_target", [
             {
@@ -137,6 +205,12 @@ export class SignalGroup extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Unblocks all signal handlers managed by `self` so they will be
+     * called again during any signal emissions unless it is blocked
+     * again. Must be unblocked exactly the same number of times it
+     * has been blocked to become active again.
+     */
     unblock() {
         call("libgobject-2.0.so.0", "g_signal_group_unblock", [
             {

package/dist/generated/gobject/type-module.d.ts

@@ -4,14 +4,109 @@ import { GObject } from "./object.js";
 export declare class TypeModule extends GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Registers an additional interface for a type, whose interface lives
+     * in the given type plugin. If the interface was already registered
+     * for the type in this plugin, nothing will be done.
+     *
+     * As long as any instances of the type exist, the type plugin will
+     * not be unloaded.
+     *
+     * Since 2.56 if `module` is %NULL this will call g_type_add_interface_static()
+     * instead. This can be used when making a static build of the module.
+     * @param instanceType - type to which to add the interface.
+     * @param interfaceType - interface type to add
+     * @param interfaceInfo - type information structure
+     */
     addInterface(instanceType: number, interfaceType: number, interfaceInfo: number): void;
+    /**
+     * Looks up or registers an enumeration that is implemented with a particular
+     * type plugin. If a type with name `type_name` was previously registered,
+     * the #GType identifier for the type is returned, otherwise the type
+     * is newly registered, and the resulting #GType identifier returned.
+     *
+     * As long as any instances of the type exist, the type plugin will
+     * not be unloaded.
+     *
+     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+     * instead. This can be used when making a static build of the module.
+     * @param name - name for the type
+     * @param constStaticValues - an array of #GEnumValue
+     */
     registerEnum(name: string, constStaticValues: number[]): number;
+    /**
+     * Looks up or registers a flags type that is implemented with a particular
+     * type plugin. If a type with name `type_name` was previously registered,
+     * the #GType identifier for the type is returned, otherwise the type
+     * is newly registered, and the resulting #GType identifier returned.
+     *
+     * As long as any instances of the type exist, the type plugin will
+     * not be unloaded.
+     *
+     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+     * instead. This can be used when making a static build of the module.
+     * @param name - name for the type
+     * @param constStaticValues - an array of #GFlagsValue
+     */
     registerFlags(name: string, constStaticValues: number[]): number;
+    /**
+     * Looks up or registers a type that is implemented with a particular
+     * type plugin. If a type with name `type_name` was previously registered,
+     * the #GType identifier for the type is returned, otherwise the type
+     * is newly registered, and the resulting #GType identifier returned.
+     *
+     * When reregistering a type (typically because a module is unloaded
+     * then reloaded, and reinitialized), `module` and `parent_type` must
+     * be the same as they were previously.
+     *
+     * As long as any instances of the type exist, the type plugin will
+     * not be unloaded.
+     *
+     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+     * instead. This can be used when making a static build of the module.
+     * @param parentType - the type for the parent class
+     * @param typeName - name for the type
+     * @param typeInfo - type information structure
+     * @param flags - flags field providing details about the type
+     */
     registerType(parentType: number, typeName: string, typeInfo: number, flags: TypeFlags): number;
+    /**
+     * Sets the name for a #GTypeModule
+     * @param name - a human-readable name to use in error messages.
+     */
     setName(name: string): void;
+    /**
+     * Decreases the use count of a #GTypeModule by one. If the
+     * result is zero, the module will be unloaded. (However, the
+     * #GTypeModule will not be freed, and types associated with the
+     * #GTypeModule are not unregistered. Once a #GTypeModule is
+     * initialized, it must exist forever.)
+     */
     unuse(): void;
+    /**
+     * Increases the use count of a #GTypeModule by one. If the
+     * use count was zero before, the plugin will be loaded.
+     * If loading the plugin fails, the use count is reset to
+     * its prior value.
+     */
     use(): boolean;
+    /**
+     * Calls the `complete_interface_info` function from the
+     * #GTypePluginClass of @plugin. There should be no need to use this
+     * function outside of the GObject type system itself.
+     * @param instanceType - the #GType of an instantiatable type to which the interface
+     * @param interfaceType - the #GType of the interface whose info is completed
+     * @param info - the #GInterfaceInfo to fill in
+     */
     completeInterfaceInfo(instanceType: number, interfaceType: number, info: number): void;
+    /**
+     * Calls the `complete_type_info` function from the #GTypePluginClass of @plugin.
+     * There should be no need to use this function outside of the GObject
+     * type system itself.
+     * @param gType - the #GType whose info is completed
+     * @param info - the #GTypeInfo struct to fill in
+     * @param valueTable - the #GTypeValueTable to fill in
+     */
     completeTypeInfo(gType: number, info: number, valueTable: number): void;
     connect(signal: "notify", handler: (self: TypeModule, pspec: ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gobject/type-module.js

@@ -2,6 +2,39 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { ParamSpec } from "./param-spec.js";
 import { GObject } from "./object.js";
+/**
+ * `GTypeModule` provides a simple implementation of the `GTypePlugin`
+ * interface.
+ *
+ * The model of `GTypeModule` is a dynamically loaded module which
+ * implements some number of types and interface implementations.
+ *
+ * When the module is loaded, it registers its types and interfaces
+ * using [method@GObject.TypeModule.register_type] and
+ * [method@GObject.TypeModule.add_interface].
+ * As long as any instances of these types and interface implementations
+ * are in use, the module is kept loaded. When the types and interfaces
+ * are gone, the module may be unloaded. If the types and interfaces
+ * become used again, the module will be reloaded. Note that the last
+ * reference cannot be released from within the module code, since that
+ * would lead to the caller's code being unloaded before `g_object_unref()`
+ * returns to it.
+ *
+ * Keeping track of whether the module should be loaded or not is done by
+ * using a use count - it starts at zero, and whenever it is greater than
+ * zero, the module is loaded. The use count is maintained internally by
+ * the type system, but also can be explicitly controlled by
+ * [method@GObject.TypeModule.use] and [method@GObject.TypeModule.unuse].
+ * Typically, when loading a module for the first type, `g_type_module_use()`
+ * will be used to load it so that it can initialize its types. At some later
+ * point, when the module no longer needs to be loaded except for the type
+ * implementations it contains, `g_type_module_unuse()` is called.
+ *
+ * `GTypeModule` does not actually provide any implementation of module
+ * loading and unloading. To create a particular module type you must
+ * derive from `GTypeModule` and implement the load and unload functions
+ * in `GTypeModuleClass`.
+ */
 const SIGNAL_META = {
     notify: {
         params: [
@@ -25,6 +58,20 @@ export class TypeModule extends GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Registers an additional interface for a type, whose interface lives
+     * in the given type plugin. If the interface was already registered
+     * for the type in this plugin, nothing will be done.
+     *
+     * As long as any instances of the type exist, the type plugin will
+     * not be unloaded.
+     *
+     * Since 2.56 if `module` is %NULL this will call g_type_add_interface_static()
+     * instead. This can be used when making a static build of the module.
+     * @param instanceType - type to which to add the interface.
+     * @param interfaceType - interface type to add
+     * @param interfaceInfo - type information structure
+     */
     addInterface(instanceType, interfaceType, interfaceInfo) {
         call("libgobject-2.0.so.0", "g_type_module_add_interface", [
             {
@@ -45,6 +92,20 @@ export class TypeModule extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Looks up or registers an enumeration that is implemented with a particular
+     * type plugin. If a type with name `type_name` was previously registered,
+     * the #GType identifier for the type is returned, otherwise the type
+     * is newly registered, and the resulting #GType identifier returned.
+     *
+     * As long as any instances of the type exist, the type plugin will
+     * not be unloaded.
+     *
+     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+     * instead. This can be used when making a static build of the module.
+     * @param name - name for the type
+     * @param constStaticValues - an array of #GEnumValue
+     */
     registerEnum(name, constStaticValues) {
         return call("libgobject-2.0.so.0", "g_type_module_register_enum", [
             {
@@ -64,6 +125,20 @@ export class TypeModule extends GObject {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Looks up or registers a flags type that is implemented with a particular
+     * type plugin. If a type with name `type_name` was previously registered,
+     * the #GType identifier for the type is returned, otherwise the type
+     * is newly registered, and the resulting #GType identifier returned.
+     *
+     * As long as any instances of the type exist, the type plugin will
+     * not be unloaded.
+     *
+     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+     * instead. This can be used when making a static build of the module.
+     * @param name - name for the type
+     * @param constStaticValues - an array of #GFlagsValue
+     */
     registerFlags(name, constStaticValues) {
         return call("libgobject-2.0.so.0", "g_type_module_register_flags", [
             {
@@ -83,6 +158,26 @@ export class TypeModule extends GObject {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Looks up or registers a type that is implemented with a particular
+     * type plugin. If a type with name `type_name` was previously registered,
+     * the #GType identifier for the type is returned, otherwise the type
+     * is newly registered, and the resulting #GType identifier returned.
+     *
+     * When reregistering a type (typically because a module is unloaded
+     * then reloaded, and reinitialized), `module` and `parent_type` must
+     * be the same as they were previously.
+     *
+     * As long as any instances of the type exist, the type plugin will
+     * not be unloaded.
+     *
+     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+     * instead. This can be used when making a static build of the module.
+     * @param parentType - the type for the parent class
+     * @param typeName - name for the type
+     * @param typeInfo - type information structure
+     * @param flags - flags field providing details about the type
+     */
     registerType(parentType, typeName, typeInfo, flags) {
         return call("libgobject-2.0.so.0", "g_type_module_register_type", [
             {
@@ -107,6 +202,10 @@ export class TypeModule extends GObject {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Sets the name for a #GTypeModule
+     * @param name - a human-readable name to use in error messages.
+     */
     setName(name) {
         call("libgobject-2.0.so.0", "g_type_module_set_name", [
             {
@@ -119,6 +218,13 @@ export class TypeModule extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Decreases the use count of a #GTypeModule by one. If the
+     * result is zero, the module will be unloaded. (However, the
+     * #GTypeModule will not be freed, and types associated with the
+     * #GTypeModule are not unregistered. Once a #GTypeModule is
+     * initialized, it must exist forever.)
+     */
     unuse() {
         call("libgobject-2.0.so.0", "g_type_module_unuse", [
             {
@@ -127,6 +233,12 @@ export class TypeModule extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Increases the use count of a #GTypeModule by one. If the
+     * use count was zero before, the plugin will be loaded.
+     * If loading the plugin fails, the use count is reset to
+     * its prior value.
+     */
     use() {
         return call("libgobject-2.0.so.0", "g_type_module_use", [
             {
@@ -135,6 +247,14 @@ export class TypeModule extends GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Calls the `complete_interface_info` function from the
+     * #GTypePluginClass of @plugin. There should be no need to use this
+     * function outside of the GObject type system itself.
+     * @param instanceType - the #GType of an instantiatable type to which the interface
+     * @param interfaceType - the #GType of the interface whose info is completed
+     * @param info - the #GInterfaceInfo to fill in
+     */
     completeInterfaceInfo(instanceType, interfaceType, info) {
         call("libgobject-2.0.so.0", "g_type_plugin_complete_interface_info", [
             {
@@ -155,6 +275,14 @@ export class TypeModule extends GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Calls the `complete_type_info` function from the #GTypePluginClass of @plugin.
+     * There should be no need to use this function outside of the GObject
+     * type system itself.
+     * @param gType - the #GType whose info is completed
+     * @param info - the #GTypeInfo struct to fill in
+     * @param valueTable - the #GTypeValueTable to fill in
+     */
     completeTypeInfo(gType, info, valueTable) {
         call("libgobject-2.0.so.0", "g_type_plugin_complete_type_info", [
             {

package/dist/generated/gobject/type-plugin.d.ts

@@ -1,9 +1,85 @@
+/**
+ * An interface that handles the lifecycle of dynamically loaded types.
+ *
+ * The GObject type system supports dynamic loading of types.
+ * It goes as follows:
+ *
+ * 1. The type is initially introduced (usually upon loading the module
+ * the first time, or by your main application that knows what modules
+ * introduces what types), like this:
+ * ```c
+ * new_type_id = g_type_register_dynamic (parent_type_id,
+ * "TypeName",
+ * new_type_plugin,
+ * type_flags);
+ * ```
+ * where `new_type_plugin` is an implementation of the
+ * `GTypePlugin` interface.
+ *
+ * 2. The type's implementation is referenced, e.g. through
+ * [func@GObject.TypeClass.ref] or through [func@GObject.type_create_instance]
+ * (this is being called by [ctor@GObject.Object.new]) or through one of the above
+ * done on a type derived from `new_type_id`.
+ *
+ * 3. This causes the type system to load the type's implementation by calling
+ * [method@GObject.TypePlugin.use] and [method@GObject.TypePlugin.complete_type_info]
+ * on `new_type_plugin`.
+ *
+ * 4. At some point the type's implementation isn't required anymore, e.g. after
+ * [method@GObject.TypeClass.unref] or [func@GObject.type_free_instance]
+ * (called when the reference count of an instance drops to zero).
+ *
+ * 5. This causes the type system to throw away the information retrieved
+ * from [method@GObject.TypePlugin.complete_type_info] and then it calls
+ * [method@GObject.TypePlugin.unuse] on `new_type_plugin`.
+ *
+ * 6. Things may repeat from the second step.
+ *
+ * So basically, you need to implement a `GTypePlugin` type that
+ * carries a use_count, once use_count goes from zero to one, you need
+ * to load the implementation to successfully handle the upcoming
+ * [method@GObject.TypePlugin.complete_type_info] call. Later, maybe after
+ * succeeding use/unuse calls, once use_count drops to zero, you can
+ * unload the implementation again. The type system makes sure to call
+ * [method@GObject.TypePlugin.use] and [method@GObject.TypePlugin.complete_type_info]
+ * again when the type is needed again.
+ *
+ * [class@GObject.TypeModule] is an implementation of `GTypePlugin` that
+ * already implements most of this except for the actual module loading and
+ * unloading. It even handles multiple registered types per module.
+ */
 export declare class TypePlugin {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): TypePlugin;
+    /**
+     * Calls the `complete_interface_info` function from the
+     * #GTypePluginClass of @plugin. There should be no need to use this
+     * function outside of the GObject type system itself.
+     * @param instanceType - the #GType of an instantiatable type to which the interface
+     * @param interfaceType - the #GType of the interface whose info is completed
+     * @param info - the #GInterfaceInfo to fill in
+     */
     completeInterfaceInfo(instanceType: number, interfaceType: number, info: number): void;
+    /**
+     * Calls the `complete_type_info` function from the #GTypePluginClass of @plugin.
+     * There should be no need to use this function outside of the GObject
+     * type system itself.
+     * @param gType - the #GType whose info is completed
+     * @param info - the #GTypeInfo struct to fill in
+     * @param valueTable - the #GTypeValueTable to fill in
+     */
     completeTypeInfo(gType: number, info: number, valueTable: number): void;
+    /**
+     * Calls the `unuse_plugin` function from the #GTypePluginClass of
+     * @plugin.  There should be no need to use this function outside of
+     * the GObject type system itself.
+     */
     unuse(): void;
+    /**
+     * Calls the `use_plugin` function from the #GTypePluginClass of
+     * @plugin.  There should be no need to use this function outside of
+     * the GObject type system itself.
+     */
     use(): void;
 }