@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/functions.js

@@ -6,6 +6,13 @@ import { PageSetup } from "./page-setup.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Pango from "../pango/index.js";
+/**
+ * Gets the modifier mask.
+ *
+ * The modifier mask determines which modifiers are considered significant
+ * for keyboard accelerators. This includes all keyboard modifiers except
+ * for `GDK_LOCK_MASK`.
+ */
 export const acceleratorGetDefaultModMask = () => {
     return call("libgtk-4.so.1", "gtk_accelerator_get_default_mod_mask", [], {
         type: "int",
@@ -13,6 +20,12 @@ export const acceleratorGetDefaultModMask = () => {
         unsigned: false,
     });
 };
+/**
+ * Converts an accelerator keyval and modifier mask into a string
+ * which can be used to represent the accelerator to the user.
+ * @param acceleratorKey - accelerator keyval
+ * @param acceleratorMods - accelerator modifier mask
+ */
 export const acceleratorGetLabel = (acceleratorKey, acceleratorMods) => {
     return call("libgtk-4.so.1", "gtk_accelerator_get_label", [
         {
@@ -25,6 +38,21 @@ export const acceleratorGetLabel = (acceleratorKey, acceleratorMods) => {
         },
     ], { type: "string" });
 };
+/**
+ * Converts an accelerator keyval and modifier mask
+ * into a string that can be displayed to the user.
+ *
+ * The string may be translated.
+ *
+ * This function is similar to [func@Gtk.accelerator_get_label],
+ * but handling keycodes. This is only useful for system-level
+ * components, applications should use [func@Gtk.accelerator_get_label]
+ * instead.
+ * @param display - a `GdkDisplay`
+ * @param acceleratorKey - accelerator keyval
+ * @param keycode - accelerator keycode
+ * @param acceleratorMods - accelerator modifier mask
+ */
 export const acceleratorGetLabelWithKeycode = (acceleratorKey, keycode, acceleratorMods, display) => {
     return call("libgtk-4.so.1", "gtk_accelerator_get_label_with_keycode", [
         {
@@ -46,6 +74,18 @@ export const acceleratorGetLabelWithKeycode = (acceleratorKey, keycode, accelera
         },
     ], { type: "string" });
 };
+/**
+ * Converts an accelerator keyval and modifier mask into a string
+ * that can be parsed by [func@Gtk.accelerator_parse].
+ *
+ * For example, if you pass in `GDK_KEY_q` and `GDK_CONTROL_MASK`,
+ * this function returns `<Control>q`.
+ *
+ * If you need to display accelerators in the user interface,
+ * see [func@Gtk.accelerator_get_label].
+ * @param acceleratorKey - accelerator keyval
+ * @param acceleratorMods - accelerator modifier mask
+ */
 export const acceleratorName = (acceleratorKey, acceleratorMods) => {
     return call("libgtk-4.so.1", "gtk_accelerator_name", [
         {
@@ -58,6 +98,18 @@ export const acceleratorName = (acceleratorKey, acceleratorMods) => {
         },
     ], { type: "string" });
 };
+/**
+ * Converts an accelerator keyval and modifier mask
+ * into a string that can be parsed by [func@Gtk.accelerator_parse_with_keycode].
+ *
+ * This is similar to [func@Gtk.accelerator_name] but handling keycodes.
+ * This is only useful for system-level components, applications
+ * should use [func@Gtk.accelerator_name] instead.
+ * @param display - a `GdkDisplay`
+ * @param acceleratorKey - accelerator keyval
+ * @param keycode - accelerator keycode
+ * @param acceleratorMods - accelerator modifier mask
+ */
 export const acceleratorNameWithKeycode = (acceleratorKey, keycode, acceleratorMods, display) => {
     return call("libgtk-4.so.1", "gtk_accelerator_name_with_keycode", [
         {
@@ -79,6 +131,34 @@ export const acceleratorNameWithKeycode = (acceleratorKey, keycode, acceleratorM
         },
     ], { type: "string" });
 };
+/**
+ * Parses a string representing an accelerator.
+ *
+ * The format looks like “`<Control>a`” or “`<Shift><Alt>F1`”.
+ *
+ * The parser is fairly liberal and allows lower or upper case, and also
+ * abbreviations such as “`<Ctl>`” and “`<Ctrl>`”.
+ *
+ * Key names are parsed using [func@Gdk.keyval_from_name]. For character keys
+ * the name is not the symbol, but the lowercase name, e.g. one would use
+ * “`<Ctrl>minus`” instead of “`<Ctrl>-`”.
+ *
+ * Modifiers are enclosed in angular brackets `<>`, and match the
+ * [flags@Gdk.ModifierType] mask:
+ *
+ * - `<Shift>` for `GDK_SHIFT_MASK`
+ * - `<Ctrl>` for `GDK_CONTROL_MASK`
+ * - `<Alt>` for `GDK_ALT_MASK`
+ * - `<Meta>` for `GDK_META_MASK`
+ * - `<Super>` for `GDK_SUPER_MASK`
+ * - `<Hyper>` for `GDK_HYPER_MASK`
+ *
+ * If the parse operation fails, `accelerator_key` and `accelerator_mods` will
+ * be set to 0 (zero).
+ * @param accelerator - string representing an accelerator
+ * @param acceleratorKey - return location for accelerator keyval
+ * @param acceleratorMods - return location for accelerator
+ */
 export const acceleratorParse = (accelerator, acceleratorKey, acceleratorMods) => {
     return call("libgtk-4.so.1", "gtk_accelerator_parse", [
         {
@@ -103,6 +183,26 @@ export const acceleratorParse = (accelerator, acceleratorKey, acceleratorMods) =
         },
     ], { type: "boolean" });
 };
+/**
+ * Parses a string representing an accelerator.
+ *
+ * This is similar to [func@Gtk.accelerator_parse] but handles keycodes as
+ * well. This is only useful for system-level components, applications should
+ * use [func@Gtk.accelerator_parse] instead.
+ *
+ * If `accelerator_codes` is given and the result stored in it is non-%NULL,
+ * the result must be freed with g_free().
+ *
+ * If a keycode is present in the accelerator and no `accelerator_codes` is given, the parse will fail.
+ *
+ * If the parse fails, @accelerator_key, `accelerator_mods` and
+ * `accelerator_codes` will be set to 0 (zero).
+ * @param accelerator - string representing an accelerator
+ * @param display - the `GdkDisplay` to look up `accelerator_codes` in
+ * @param acceleratorKey - return location for accelerator keyval
+ * @param acceleratorCodes - return location for accelerator keycodes
+ * @param acceleratorMods - return location for accelerator
+ */
 export const acceleratorParseWithKeycode = (accelerator, display, acceleratorKey, acceleratorCodes, acceleratorMods) => {
     return call("libgtk-4.so.1", "gtk_accelerator_parse_with_keycode", [
         {
@@ -143,6 +243,16 @@ export const acceleratorParseWithKeycode = (accelerator, display, acceleratorKey
         },
     ], { type: "boolean" });
 };
+/**
+ * Determines whether a given keyval and modifier mask constitute
+ * a valid keyboard accelerator.
+ *
+ * For example, the `GDK_KEY_a` keyval plus `GDK_CONTROL_MASK` mask is valid,
+ * and matches the “Ctrl+a” accelerator. But, you can't, for instance, use
+ * the `GDK_KEY_Control_L` keyval as an accelerator.
+ * @param keyval - a GDK keyval
+ * @param modifiers - modifier mask
+ */
 export const acceleratorValid = (keyval, modifiers) => {
     return call("libgtk-4.so.1", "gtk_accelerator_valid", [
         {
@@ -155,6 +265,14 @@ export const acceleratorValid = (keyval, modifiers) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Initializes `value` with the appropriate type for the @property.
+ *
+ * This function is mostly meant for language bindings, in conjunction
+ * with gtk_accessible_update_property_value().
+ * @param property - a `GtkAccessibleProperty`
+ * @param value - an uninitialized `GValue`
+ */
 export const accessiblePropertyInitValue = (property, value) => {
     call("libgtk-4.so.1", "gtk_accessible_property_init_value", [
         {
@@ -172,6 +290,14 @@ export const accessiblePropertyInitValue = (property, value) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Initializes `value` with the appropriate type for the @relation.
+ *
+ * This function is mostly meant for language bindings, in conjunction
+ * with gtk_accessible_update_relation_value().
+ * @param relation - a `GtkAccessibleRelation`
+ * @param value - an uninitialized `GValue`
+ */
 export const accessibleRelationInitValue = (relation, value) => {
     call("libgtk-4.so.1", "gtk_accessible_relation_init_value", [
         {
@@ -189,6 +315,14 @@ export const accessibleRelationInitValue = (relation, value) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Initializes `value` with the appropriate type for the @state.
+ *
+ * This function is mostly meant for language bindings, in conjunction
+ * with gtk_accessible_update_relation_state().
+ * @param state - a `GtkAccessibleState`
+ * @param value - an uninitialized `GValue`
+ */
 export const accessibleStateInitValue = (state, value) => {
     call("libgtk-4.so.1", "gtk_accessible_state_init_value", [
         {
@@ -206,6 +340,16 @@ export const accessibleStateInitValue = (state, value) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Initializes `iter` to point to @target.
+ *
+ * If `target` is not found, finds the next value after it.
+ * If no value >= `target` exists in @set, this function returns %FALSE.
+ * @param iter - a pointer to an uninitialized `GtkBitsetIter`
+ * @param set - a `GtkBitset`
+ * @param target - target value to start iterating at
+ * @param value - Set to the found value in @set
+ */
 export const bitsetIterInitAt = (iter, set, target, value) => {
     return call("libgtk-4.so.1", "gtk_bitset_iter_init_at", [
         {
@@ -242,6 +386,15 @@ export const bitsetIterInitAt = (iter, set, target, value) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Initializes an iterator for `set` and points it to the first
+ * value in @set.
+ *
+ * If `set` is empty, %FALSE is returned and `value` is set to %G_MAXUINT.
+ * @param iter - a pointer to an uninitialized `GtkBitsetIter`
+ * @param set - a `GtkBitset`
+ * @param value - Set to the first value in @set
+ */
 export const bitsetIterInitFirst = (iter, set, value) => {
     return call("libgtk-4.so.1", "gtk_bitset_iter_init_first", [
         {
@@ -274,6 +427,15 @@ export const bitsetIterInitFirst = (iter, set, value) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Initializes an iterator for `set` and points it to the last
+ * value in @set.
+ *
+ * If `set` is empty, %FALSE is returned.
+ * @param iter - a pointer to an uninitialized `GtkBitsetIter`
+ * @param set - a `GtkBitset`
+ * @param value - Set to the last value in @set
+ */
 export const bitsetIterInitLast = (iter, set, value) => {
     return call("libgtk-4.so.1", "gtk_bitset_iter_init_last", [
         {
@@ -306,6 +468,9 @@ export const bitsetIterInitLast = (iter, set, value) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Registers an error quark for [class@Gtk.Builder] errors.
+ */
 export const builderErrorQuark = () => {
     return call("libgtk-4.so.1", "gtk_builder_error_quark", [], {
         type: "int",
@@ -313,6 +478,33 @@ export const builderErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Checks that the GTK library in use is compatible with the
+ * given version.
+ *
+ * Generally you would pass in the constants %GTK_MAJOR_VERSION,
+ * %GTK_MINOR_VERSION, %GTK_MICRO_VERSION as the three arguments
+ * to this function; that produces a check that the library in
+ * use is compatible with the version of GTK the application or
+ * module was compiled against.
+ *
+ * Compatibility is defined by two things: first the version
+ * of the running library is newer than the version
+ * @required_major.required_minor.@required_micro. Second
+ * the running library must be binary compatible with the
+ * version @required_major.required_minor.`required_micro` (same major version.)
+ *
+ * This function is primarily for GTK modules; the module
+ * can call this function to check that it wasn’t loaded
+ * into an incompatible version of GTK. However, such a
+ * check isn’t completely reliable, since the module may be
+ * linked against an old version of GTK and calling the
+ * old version of gtk_check_version(), but still get loaded
+ * into an application using a newer version of GTK.
+ * @param requiredMajor - the required major version
+ * @param requiredMinor - the required minor version
+ * @param requiredMicro - the required micro version
+ */
 export const checkVersion = (requiredMajor, requiredMinor, requiredMicro) => {
     return call("libgtk-4.so.1", "gtk_check_version", [
         {
@@ -329,6 +521,9 @@ export const checkVersion = (requiredMajor, requiredMinor, requiredMicro) => {
         },
     ], { type: "string", borrowed: true });
 };
+/**
+ * Registers an error quark for VFL error parsing.
+ */
 export const constraintVflParserErrorQuark = () => {
     return call("libgtk-4.so.1", "gtk_constraint_vfl_parser_error_quark", [], {
         type: "int",
@@ -336,6 +531,9 @@ export const constraintVflParserErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Registers an error quark for CSS parsing errors.
+ */
 export const cssParserErrorQuark = () => {
     return call("libgtk-4.so.1", "gtk_css_parser_error_quark", [], {
         type: "int",
@@ -343,6 +541,9 @@ export const cssParserErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Registers an error quark for CSS parsing warnings.
+ */
 export const cssParserWarningQuark = () => {
     return call("libgtk-4.so.1", "gtk_css_parser_warning_quark", [], {
         type: "int",
@@ -350,6 +551,10 @@ export const cssParserWarningQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Registers an error quark for an operation that requires a dialog if
+ * necessary.
+ */
 export const dialogErrorQuark = () => {
     return call("libgtk-4.so.1", "gtk_dialog_error_quark", [], {
         type: "int",
@@ -357,12 +562,39 @@ export const dialogErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Prevents GTK from using portals.
+ *
+ * This is equivalent to setting `GDK_DEBUG=no-portals` in the environment.
+ *
+ * This should only be used in portal implementations, apps must not call it.
+ */
 export const disablePortals = () => {
     call("libgtk-4.so.1", "gtk_disable_portals", [], { type: "undefined" });
 };
+/**
+ * Prevents [func@Gtk.init] and [func@Gtk.init_check] from calling `setlocale()`.
+ *
+ * You would want to use this function if you wanted to set the locale for
+ * your program to something other than the user’s locale, or if you wanted
+ * to set different values for different locale categories.
+ *
+ * Most programs should not need to call this function.
+ */
 export const disableSetlocale = () => {
     call("libgtk-4.so.1", "gtk_disable_setlocale", [], { type: "undefined" });
 };
+/**
+ * Distributes `extra_space` to child `sizes` by bringing smaller
+ * children up to natural size first.
+ *
+ * The remaining space will be added to the `minimum_size` member of the
+ * `GtkRequestedSize` struct. If all sizes reach their natural size then
+ * the remaining space is returned.
+ * @param extraSpace - Extra space to redistribute among children after subtracting
+ * @param nRequestedSizes - Number of requests to fit into the allocation
+ * @param sizes - An array of structs with a client pointer and a minimum/natural size
+ */
 export const distributeNaturalAllocation = (extraSpace, nRequestedSizes, sizes) => {
     return call("libgtk-4.so.1", "gtk_distribute_natural_allocation", [
         {
@@ -382,6 +614,17 @@ export const distributeNaturalAllocation = (extraSpace, nRequestedSizes, sizes)
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Gets a property of the `GtkEditable` delegate for @object.
+ *
+ * This is helper function that should be called in the `get_property`
+ * function of your `GtkEditable` implementation, before handling your
+ * own properties.
+ * @param object - a `GObject`
+ * @param propId - a property ID
+ * @param value - value to set
+ * @param pspec - the `GParamSpec` for the property
+ */
 export const editableDelegateGetProperty = (object, propId, value, pspec) => {
     return call("libgtk-4.so.1", "gtk_editable_delegate_get_property", [
         {
@@ -407,6 +650,17 @@ export const editableDelegateGetProperty = (object, propId, value, pspec) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Sets a property on the `GtkEditable` delegate for @object.
+ *
+ * This is a helper function that should be called in the `set_property`
+ * function of your `GtkEditable` implementation, before handling your
+ * own properties.
+ * @param object - a `GObject`
+ * @param propId - a property ID
+ * @param value - value to set
+ * @param pspec - the `GParamSpec` for the property
+ */
 export const editableDelegateSetProperty = (object, propId, value, pspec) => {
     return call("libgtk-4.so.1", "gtk_editable_delegate_set_property", [
         {
@@ -432,6 +686,25 @@ export const editableDelegateSetProperty = (object, propId, value, pspec) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Overrides the `GtkEditable` properties for @class.
+ *
+ * This is a helper function that should be called in class_init,
+ * after installing your own properties.
+ *
+ * Note that your class must have "text", "cursor-position",
+ * "selection-bound", "editable", "width-chars", "max-width-chars",
+ * "xalign" and "enable-undo" properties for this function to work.
+ *
+ * To handle the properties in your set_property and get_property
+ * functions, you can either use [func@Gtk.Editable.delegate_set_property]
+ * and [func@Gtk.Editable.delegate_get_property] (if you are using
+ * a delegate), or remember the `first_prop` offset and add it to the
+ * values in the [enum@Gtk.EditableProperties] enumeration to get the
+ * property IDs for these properties.
+ * @param objectClass - a `GObjectClass`
+ * @param firstProp - property ID to use for the first property
+ */
 export const editableInstallProperties = (objectClass, firstProp) => {
     return call("libgtk-4.so.1", "gtk_editable_install_properties", [
         {
@@ -444,6 +717,15 @@ export const editableInstallProperties = (objectClass, firstProp) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Calls a function for all printers that are known to GTK.
+ *
+ * If `func` returns true, the enumeration is stopped.
+ * @param func - a function to call for each printer
+ * @param data - user data to pass to @func
+ * @param destroy - function to call if `data` is no longer needed
+ * @param wait - if true, wait in a recursive mainloop until
+ */
 export const enumeratePrinters = (func, destroy, wait, data) => {
     call("libgtk-4.so.1", "gtk_enumerate_printers", [
         {
@@ -465,6 +747,9 @@ export const enumeratePrinters = (func, destroy, wait, data) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Registers an error quark for `GtkFileChooser` errors.
+ */
 export const fileChooserErrorQuark = () => {
     return call("libgtk-4.so.1", "gtk_file_chooser_error_quark", [], {
         type: "int",
@@ -472,6 +757,11 @@ export const fileChooserErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Returns the binary age as passed to `libtool`.
+ *
+ * If `libtool` means nothing to you, don't worry about it.
+ */
 export const getBinaryAge = () => {
     return call("libgtk-4.so.1", "gtk_get_binary_age", [], {
         type: "int",
@@ -479,6 +769,12 @@ export const getBinaryAge = () => {
         unsigned: true,
     });
 };
+/**
+ * Returns the GTK debug flags that are currently active.
+ *
+ * This function is intended for GTK modules that want
+ * to adjust their debug output based on GTK debug flags.
+ */
 export const getDebugFlags = () => {
     return call("libgtk-4.so.1", "gtk_get_debug_flags", [], {
         type: "int",
@@ -486,6 +782,20 @@ export const getDebugFlags = () => {
         unsigned: false,
     });
 };
+/**
+ * Returns the `PangoLanguage` for the default language
+ * currently in effect.
+ *
+ * Note that this can change over the life of an
+ * application.
+ *
+ * The default language is derived from the current
+ * locale. It determines, for example, whether GTK uses
+ * the right-to-left or left-to-right text direction.
+ *
+ * This function is equivalent to [func@Pango.Language.get_default].
+ * See that function for details.
+ */
 export const getDefaultLanguage = () => {
     const ptr = call("libgtk-4.so.1", "gtk_get_default_language", [], {
         type: "boxed",
@@ -495,6 +805,11 @@ export const getDefaultLanguage = () => {
     });
     return getObject(ptr, Pango.Language);
 };
+/**
+ * Returns the interface age as passed to `libtool`.
+ *
+ * If `libtool` means nothing to you, don't worry about it.
+ */
 export const getInterfaceAge = () => {
     return call("libgtk-4.so.1", "gtk_get_interface_age", [], {
         type: "int",
@@ -502,6 +817,34 @@ export const getInterfaceAge = () => {
         unsigned: true,
     });
 };
+/**
+ * Gets the direction of the current locale.
+ *
+ * This is the expected reading direction for text and UI.
+ *
+ * This function depends on the current locale being set with
+ * `setlocale()` and will default to setting the `GTK_TEXT_DIR_LTR`
+ * direction otherwise. `GTK_TEXT_DIR_NONE` will never be returned.
+ *
+ * GTK sets the default text direction according to the locale during
+ * [func@Gtk.init], and you should normally use [method@Gtk.Widget.get_direction]
+ * or [func@Gtk.Widget.get_default_direction] to obtain the current direction.
+ *
+ * This function is only needed rare cases when the locale is
+ * changed after GTK has already been initialized. In this case,
+ * you can use it to update the default text direction as follows:
+ *
+ * ```c
+ * #include <locale.h>
+ *
+ * static void
+ * update_locale (const char *new_locale)
+ * {
+ * setlocale (LC_ALL, new_locale);
+ * gtk_widget_set_default_direction (gtk_get_locale_direction ());
+ * }
+ * ```
+ */
 export const getLocaleDirection = () => {
     return call("libgtk-4.so.1", "gtk_get_locale_direction", [], {
         type: "int",
@@ -509,6 +852,16 @@ export const getLocaleDirection = () => {
         unsigned: false,
     });
 };
+/**
+ * Returns the major version number of the GTK library.
+ *
+ * For example, in GTK version 3.1.5 this is 3.
+ *
+ * This function is in the library, so it represents the GTK library
+ * your code is running against. Contrast with the %GTK_MAJOR_VERSION
+ * macro, which represents the major version of the GTK headers you
+ * have included when compiling your code.
+ */
 export const getMajorVersion = () => {
     return call("libgtk-4.so.1", "gtk_get_major_version", [], {
         type: "int",
@@ -516,6 +869,16 @@ export const getMajorVersion = () => {
         unsigned: true,
     });
 };
+/**
+ * Returns the micro version number of the GTK library.
+ *
+ * For example, in GTK version 3.1.5 this is 5.
+ *
+ * This function is in the library, so it represents the GTK library
+ * your code is are running against. Contrast with the
+ * %GTK_MICRO_VERSION macro, which represents the micro version of the
+ * GTK headers you have included when compiling your code.
+ */
 export const getMicroVersion = () => {
     return call("libgtk-4.so.1", "gtk_get_micro_version", [], {
         type: "int",
@@ -523,6 +886,16 @@ export const getMicroVersion = () => {
         unsigned: true,
     });
 };
+/**
+ * Returns the minor version number of the GTK library.
+ *
+ * For example, in GTK version 3.1.5 this is 1.
+ *
+ * This function is in the library, so it represents the GTK library
+ * your code is are running against. Contrast with the
+ * %GTK_MINOR_VERSION macro, which represents the minor version of the
+ * GTK headers you have included when compiling your code.
+ */
 export const getMinorVersion = () => {
     return call("libgtk-4.so.1", "gtk_get_minor_version", [], {
         type: "int",
@@ -530,6 +903,18 @@ export const getMinorVersion = () => {
         unsigned: true,
     });
 };
+/**
+ * Converts a color from HSV space to RGB.
+ *
+ * Input values must be in the [0.0, 1.0] range;
+ * output values will be in the same range.
+ * @param h - Hue
+ * @param s - Saturation
+ * @param v - Value
+ * @param r - Return value for the red component
+ * @param g - Return value for the green component
+ * @param b - Return value for the blue component
+ */
 export const hsvToRgb = (h, s, v, r, g, b) => {
     call("libgtk-4.so.1", "gtk_hsv_to_rgb", [
         {
@@ -558,6 +943,9 @@ export const hsvToRgb = (h, s, v, r, g, b) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Registers an error quark for [class@Gtk.IconTheme] errors.
+ */
 export const iconThemeErrorQuark = () => {
     return call("libgtk-4.so.1", "gtk_icon_theme_error_quark", [], {
         type: "int",
@@ -565,19 +953,63 @@ export const iconThemeErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Initializes GTK.
+ *
+ * This function must be called before using any other GTK functions
+ * in your GUI applications.
+ *
+ * It will initialize everything needed to operate the toolkit. In particular,
+ * it will open the default display (see [func@Gdk.Display.get_default]).
+ *
+ * If you are using [class@Gtk.Application], you usually don't have to call this
+ * function; the [vfunc@Gio.Application.startup] handler does it for you. Though,
+ * if you are using `GApplication` methods that will be invoked before `startup`,
+ * such as `local_command_line`, you may need to initialize GTK explicitly.
+ *
+ * This function will terminate your program if it was unable to initialize
+ * the windowing system for some reason. If you want your program to fall back
+ * to a textual interface, call [func@Gtk.init_check] instead.
+ *
+ * GTK calls `signal (SIGPIPE, SIG_IGN)` during initialization, to ignore
+ * SIGPIPE signals, since these are almost never wanted in graphical
+ * applications. If you do need to handle SIGPIPE for some reason, reset
+ * the handler after gtk_init(), but notice that other libraries (e.g.
+ * libdbus or gvfs) might do similar things.
+ */
 export const init = () => {
     call("libgtk-4.so.1", "gtk_init", [], { type: "undefined" });
 };
+/**
+ * Initializes GTK.
+ *
+ * This function does the same work as [func@Gtk.init] with only a
+ * single change: It does not terminate the program if the windowing
+ * system can’t be initialized. Instead it returns false on failure.
+ *
+ * This way the application can fall back to some other means of
+ * communication with the user - for example a curses or command line
+ * interface.
+ */
 export const initCheck = () => {
     return call("libgtk-4.so.1", "gtk_init_check", [], {
         type: "boolean",
     });
 };
+/**
+ * Returns whether GTK has been initialized.
+ *
+ * See [func@Gtk.init].
+ */
 export const isInitialized = () => {
     return call("libgtk-4.so.1", "gtk_is_initialized", [], {
         type: "boolean",
     });
 };
+/**
+ * Finds the `GtkNative` associated with the surface.
+ * @param surface - a `GdkSurface`
+ */
 export const nativeGetForSurface = (surface) => {
     const ptr = call("libgtk-4.so.1", "gtk_native_get_for_surface", [
         {
@@ -589,12 +1021,20 @@ export const nativeGetForSurface = (surface) => {
         return null;
     return getObject(ptr, Native);
 };
+/**
+ * Returns the name of the default paper size, which
+ * depends on the current locale.
+ */
 export const paperSizeGetDefault = () => {
     return call("libgtk-4.so.1", "gtk_paper_size_get_default", [], {
         type: "string",
         borrowed: true,
     });
 };
+/**
+ * Creates a list of known paper sizes.
+ * @param includeCustom - whether to include custom paper sizes
+ */
 export const paperSizeGetPaperSizes = (includeCustom) => {
     return call("libgtk-4.so.1", "gtk_paper_size_get_paper_sizes", [
         {
@@ -612,6 +1052,15 @@ export const paperSizeGetPaperSizes = (includeCustom) => {
         borrowed: true,
     });
 };
+/**
+ * Creates a new `GParamSpec` instance for a property holding a `GtkExpression`.
+ *
+ * See `g_param_spec_internal()` for details on the property strings.
+ * @param name - canonical name of the property
+ * @param nick - a user-readable name for the property
+ * @param blurb - a user-readable description of the property
+ * @param flags - flags for the property
+ */
 export const paramSpecExpression = (name, nick, blurb, flags) => {
     const ptr = call("libgtk-4.so.1", "gtk_param_spec_expression", [
         {
@@ -633,6 +1082,9 @@ export const paramSpecExpression = (name, nick, blurb, flags) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, GObject.ParamSpec);
 };
+/**
+ * Registers an error quark for `GtkPrintOperation` if necessary.
+ */
 export const printErrorQuark = () => {
     return call("libgtk-4.so.1", "gtk_print_error_quark", [], {
         type: "int",
@@ -640,6 +1092,20 @@ export const printErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Runs a page setup dialog, letting the user modify the values from @page_setup.
+ *
+ * If the user cancels the dialog, the returned `GtkPageSetup` is identical
+ * to the passed in @page_setup, otherwise it contains the modifications
+ * done in the dialog.
+ *
+ * Note that this function may use a recursive mainloop to show the page
+ * setup dialog. See [func@Gtk.print_run_page_setup_dialog_async] if this is
+ * a problem.
+ * @param parent - transient parent
+ * @param pageSetup - an existing `GtkPageSetup`
+ * @param settings - a `GtkPrintSettings`
+ */
 export const printRunPageSetupDialog = (settings, parent, pageSetup) => {
     const ptr = call("libgtk-4.so.1", "gtk_print_run_page_setup_dialog", [
         {
@@ -659,6 +1125,18 @@ export const printRunPageSetupDialog = (settings, parent, pageSetup) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, PageSetup);
 };
+/**
+ * Runs a page setup dialog, letting the user modify the values from @page_setup.
+ *
+ * In contrast to [func@Gtk.print_run_page_setup_dialog], this function  returns
+ * after showing the page setup dialog on platforms that support this, and calls
+ * `done_cb` from a signal handler for the ::response signal of the dialog.
+ * @param parent - transient parent
+ * @param pageSetup - an existing `GtkPageSetup`
+ * @param settings - a `GtkPrintSettings`
+ * @param doneCb - a function to call when the user saves
+ * @param data - user data to pass to @done_cb
+ */
 export const printRunPageSetupDialogAsync = (settings, doneCb, parent, pageSetup, data) => {
     call("libgtk-4.so.1", "gtk_print_run_page_setup_dialog_async", [
         {
@@ -686,6 +1164,9 @@ export const printRunPageSetupDialogAsync = (settings, doneCb, parent, pageSetup
         },
     ], { type: "undefined" });
 };
+/**
+ * Registers an error quark for [class@RecentManager] errors.
+ */
 export const recentManagerErrorQuark = () => {
     return call("libgtk-4.so.1", "gtk_recent_manager_error_quark", [], {
         type: "int",
@@ -693,6 +1174,17 @@ export const recentManagerErrorQuark = () => {
         unsigned: true,
     });
 };
+/**
+ * Renders an activity indicator (such as in `GtkSpinner`).
+ * The state %GTK_STATE_FLAG_CHECKED determines whether there is
+ * activity going on.
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export const renderActivity = (context, cr, x, y, width, height) => {
     call("libgtk-4.so.1", "gtk_render_activity", [
         {
@@ -726,6 +1218,17 @@ export const renderActivity = (context, cr, x, y, width, height) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders an arrow pointing to @angle.
+ *
+ * Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param angle - arrow angle from 0 to 2 * %G_PI, being 0 the arrow pointing to the north
+ * @param x - X origin of the render area
+ * @param y - Y origin of the render area
+ * @param size - square side for render area
+ */
 export const renderArrow = (context, cr, angle, x, y, size) => {
     call("libgtk-4.so.1", "gtk_render_arrow", [
         {
@@ -759,6 +1262,18 @@ export const renderArrow = (context, cr, angle, x, y, size) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders the background of an element.
+ *
+ * Typical background rendering, showing the effect of
+ * `background-image`, `border-width` and `border-radius`:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export const renderBackground = (context, cr, x, y, width, height) => {
     call("libgtk-4.so.1", "gtk_render_background", [
         {
@@ -792,6 +1307,21 @@ export const renderBackground = (context, cr, x, y, width, height) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders a checkmark (as in a `GtkCheckButton`).
+ *
+ * The %GTK_STATE_FLAG_CHECKED state determines whether the check is
+ * on or off, and %GTK_STATE_FLAG_INCONSISTENT determines whether it
+ * should be marked as undefined.
+ *
+ * Typical checkmark rendering:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export const renderCheck = (context, cr, x, y, width, height) => {
     call("libgtk-4.so.1", "gtk_render_check", [
         {
@@ -825,6 +1355,19 @@ export const renderCheck = (context, cr, x, y, width, height) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders an expander (as used in `GtkTreeView` and `GtkExpander`) in the area
+ * defined by @x, @y, @width, @height. The state %GTK_STATE_FLAG_CHECKED
+ * determines whether the expander is collapsed or expanded.
+ *
+ * Typical expander rendering:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export const renderExpander = (context, cr, x, y, width, height) => {
     call("libgtk-4.so.1", "gtk_render_expander", [
         {
@@ -858,6 +1401,17 @@ export const renderExpander = (context, cr, x, y, width, height) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders a focus indicator on the rectangle determined by @x, @y, @width, @height.
+ *
+ * Typical focus rendering:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export const renderFocus = (context, cr, x, y, width, height) => {
     call("libgtk-4.so.1", "gtk_render_focus", [
         {
@@ -891,6 +1445,18 @@ export const renderFocus = (context, cr, x, y, width, height) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders a frame around the rectangle defined by @x, @y, @width, @height.
+ *
+ * Examples of frame rendering, showing the effect of `border-image`,
+ * `border-color`, `border-width`, `border-radius` and junctions:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export const renderFrame = (context, cr, x, y, width, height) => {
     call("libgtk-4.so.1", "gtk_render_frame", [
         {
@@ -924,6 +1490,18 @@ export const renderFrame = (context, cr, x, y, width, height) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders a handle (as in `GtkPaned` and `GtkWindow`’s resize grip),
+ * in the rectangle determined by @x, @y, @width, @height.
+ *
+ * Handles rendered for the paned and grip classes:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export const renderHandle = (context, cr, x, y, width, height) => {
     call("libgtk-4.so.1", "gtk_render_handle", [
         {
@@ -957,6 +1535,18 @@ export const renderHandle = (context, cr, x, y, width, height) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders the icon in `texture` at the specified `x` and `y` coordinates.
+ *
+ * This function will render the icon in `texture` at exactly its size,
+ * regardless of scaling factors, which may not be appropriate when
+ * drawing on displays with high pixel densities.
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param texture - a `GdkTexture` containing the icon to draw
+ * @param x - X position for the @texture
+ * @param y - Y position for the @texture
+ */
 export const renderIcon = (context, cr, texture, x, y) => {
     call("libgtk-4.so.1", "gtk_render_icon", [
         {
@@ -986,6 +1576,14 @@ export const renderIcon = (context, cr, texture, x, y) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders `layout` on the coordinates @x, @y
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin
+ * @param y - Y origin
+ * @param layout - the `PangoLayout` to render
+ */
 export const renderLayout = (context, cr, x, y, layout) => {
     call("libgtk-4.so.1", "gtk_render_layout", [
         {
@@ -1015,6 +1613,15 @@ export const renderLayout = (context, cr, x, y, layout) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders a line from (x0, y0) to (x1, y1).
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x0 - X coordinate for the origin of the line
+ * @param y0 - Y coordinate for the origin of the line
+ * @param x1 - X coordinate for the end of the line
+ * @param y1 - Y coordinate for the end of the line
+ */
 export const renderLine = (context, cr, x0, y0, x1, y1) => {
     call("libgtk-4.so.1", "gtk_render_line", [
         {
@@ -1048,6 +1655,19 @@ export const renderLine = (context, cr, x0, y0, x1, y1) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Renders an option mark (as in a radio button), the %GTK_STATE_FLAG_CHECKED
+ * state will determine whether the option is on or off, and
+ * %GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined.
+ *
+ * Typical option mark rendering:
+ * @param context - a `GtkStyleContext`
+ * @param cr - a `cairo_t`
+ * @param x - X origin of the rectangle
+ * @param y - Y origin of the rectangle
+ * @param width - rectangle width
+ * @param height - rectangle height
+ */
 export const renderOption = (context, cr, x, y, width, height) => {
     call("libgtk-4.so.1", "gtk_render_option", [
         {
@@ -1081,6 +1701,18 @@ export const renderOption = (context, cr, x, y, width, height) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Converts a color from RGB space to HSV.
+ *
+ * Input values must be in the [0.0, 1.0] range;
+ * output values will be in the same range.
+ * @param r - Red
+ * @param g - Green
+ * @param b - Blue
+ * @param h - Return value for the hue component
+ * @param s - Return value for the saturation component
+ * @param v - Return value for the value component
+ */
 export const rgbToHsv = (r, g, b, h, s, v) => {
     call("libgtk-4.so.1", "gtk_rgb_to_hsv", [
         {
@@ -1109,6 +1741,10 @@ export const rgbToHsv = (r, g, b, h, s, v) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Sets the GTK debug flags.
+ * @param flags - the debug flags to set
+ */
 export const setDebugFlags = (flags) => {
     call("libgtk-4.so.1", "gtk_set_debug_flags", [
         {
@@ -1117,6 +1753,13 @@ export const setDebugFlags = (flags) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * This function launches the default application for showing
+ * a given uri, or shows an error dialog if that fails.
+ * @param parent - parent window
+ * @param uri - the uri to show
+ * @param timestamp - timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
+ */
 export const showUri = (uri, timestamp, parent) => {
     call("libgtk-4.so.1", "gtk_show_uri", [
         {
@@ -1134,6 +1777,21 @@ export const showUri = (uri, timestamp, parent) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * This function launches the default application for showing
+ * a given uri.
+ *
+ * The `callback` will be called when the launch is completed.
+ *
+ * This is the recommended call to be used as it passes information
+ * necessary for sandbox helpers to parent their dialogs properly.
+ * @param parent - parent window
+ * @param uri - the uri to show
+ * @param timestamp - timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
+ * @param cancellable - a `GCancellable` to cancel the launch
+ * @param callback - a callback to call when the action is complete
+ * @param userData - data to pass to @callback
+ */
 export const showUriFull = (uri, timestamp, parent, cancellable, callback) => {
     call("libgtk-4.so.1", "gtk_show_uri_full", [
         {
@@ -1166,6 +1824,12 @@ export const showUriFull = (uri, timestamp, parent, cancellable, callback) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Finishes the gtk_show_uri() call and returns the result
+ * of the operation.
+ * @param parent - the `GtkWindow` passed to gtk_show_uri()
+ * @param result - `GAsyncResult` that was passed to @callback
+ */
 export const showUriFullFinish = (parent, result) => {
     const error = { value: null };
     const _result = call("libgtk-4.so.1", "gtk_show_uri_full_finish", [
@@ -1194,6 +1858,17 @@ export const showUriFullFinish = (parent, result) => {
     }
     return _result;
 };
+/**
+ * Prints an assertion message for gtk_test_accessible_assert_role().
+ * @param domain - a domain
+ * @param file - a file name
+ * @param line - the line in @file
+ * @param func - a function name in @file
+ * @param expr - the expression being tested
+ * @param accessible - a `GtkAccessible`
+ * @param expectedRole - the expected `GtkAccessibleRole`
+ * @param actualRole - the actual `GtkAccessibleRole`
+ */
 export const testAccessibleAssertionMessageRole = (domain, file, line, func, expr, accessible, expectedRole, actualRole) => {
     call("libgtk-4.so.1", "gtk_test_accessible_assertion_message_role", [
         {
@@ -1230,6 +1905,11 @@ export const testAccessibleAssertionMessageRole = (domain, file, line, func, exp
         },
     ], { type: "undefined" });
 };
+/**
+ * Checks whether the `GtkAccessible` has `property` set.
+ * @param accessible - a `GtkAccessible`
+ * @param property - a `GtkAccessibleProperty`
+ */
 export const testAccessibleHasProperty = (accessible, property) => {
     return call("libgtk-4.so.1", "gtk_test_accessible_has_property", [
         {
@@ -1242,6 +1922,11 @@ export const testAccessibleHasProperty = (accessible, property) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks whether the `GtkAccessible` has `relation` set.
+ * @param accessible - a `GtkAccessible`
+ * @param relation - a `GtkAccessibleRelation`
+ */
 export const testAccessibleHasRelation = (accessible, relation) => {
     return call("libgtk-4.so.1", "gtk_test_accessible_has_relation", [
         {
@@ -1254,6 +1939,12 @@ export const testAccessibleHasRelation = (accessible, relation) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks whether the `GtkAccessible:accessible-role` of the accessible
+ * is @role.
+ * @param accessible - a `GtkAccessible`
+ * @param role - a `GtkAccessibleRole`
+ */
 export const testAccessibleHasRole = (accessible, role) => {
     return call("libgtk-4.so.1", "gtk_test_accessible_has_role", [
         {
@@ -1266,6 +1957,11 @@ export const testAccessibleHasRole = (accessible, role) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks whether the `GtkAccessible` has `state` set.
+ * @param accessible - a `GtkAccessible`
+ * @param state - a `GtkAccessibleState`
+ */
 export const testAccessibleHasState = (accessible, state) => {
     return call("libgtk-4.so.1", "gtk_test_accessible_has_state", [
         {
@@ -1278,6 +1974,11 @@ export const testAccessibleHasState = (accessible, state) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Return the type ids that have been registered after
+ * calling gtk_test_register_all_types().
+ * @param nTypes - location to store number of types
+ */
 export const testListAllTypes = (nTypes) => {
     return call("libgtk-4.so.1", "gtk_test_list_all_types", [
         {
@@ -1289,11 +1990,28 @@ export const testListAllTypes = (nTypes) => {
         },
     ], { type: "array", itemType: { type: "int", size: 64, unsigned: true } });
 };
+/**
+ * Force registration of all core GTK object types.
+ *
+ * This allows to refer to any of those object types via
+ * g_type_from_name() after calling this function.
+ */
 export const testRegisterAllTypes = () => {
     call("libgtk-4.so.1", "gtk_test_register_all_types", [], {
         type: "undefined",
     });
 };
+/**
+ * Enters the main loop and waits for `widget` to be “drawn”.
+ *
+ * In this context that means it waits for the frame clock of
+ * `widget` to have run a full styling, layout and drawing cycle.
+ *
+ * This function is intended to be used for syncing with actions that
+ * depend on `widget` relayouting or on interaction with the display
+ * server.
+ * @param widget - the widget to wait for
+ */
 export const testWidgetWaitForDraw = (widget) => {
     call("libgtk-4.so.1", "gtk_test_widget_wait_for_draw", [
         {
@@ -1302,6 +2020,11 @@ export const testWidgetWaitForDraw = (widget) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Creates a content provider for dragging `path` from @tree_model.
+ * @param treeModel - a `GtkTreeModel`
+ * @param path - a row in @tree_model
+ */
 export const treeCreateRowDragContent = (treeModel, path) => {
     const ptr = call("libgtk-4.so.1", "gtk_tree_create_row_drag_content", [
         {
@@ -1320,6 +2043,15 @@ export const treeCreateRowDragContent = (treeModel, path) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, Gdk.ContentProvider);
 };
+/**
+ * Obtains a `tree_model` and `path` from value of target type
+ * %GTK_TYPE_TREE_ROW_DATA.
+ *
+ * The returned path must be freed with gtk_tree_path_free().
+ * @param value - a `GValue`
+ * @param treeModel - a `GtkTreeModel`
+ * @param path - row in @tree_model
+ */
 export const treeGetRowDragData = (value, treeModel, path) => {
     return call("libgtk-4.so.1", "gtk_tree_get_row_drag_data", [
         {
@@ -1350,6 +2082,13 @@ export const treeGetRowDragData = (value, treeModel, path) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Lets a set of row reference created by
+ * gtk_tree_row_reference_new_proxy() know that the
+ * model emitted the ::row-deleted signal.
+ * @param proxy - a `GObject`
+ * @param path - the path position that was deleted
+ */
 export const treeRowReferenceDeleted = (proxy, path) => {
     call("libgtk-4.so.1", "gtk_tree_row_reference_deleted", [
         {
@@ -1367,6 +2106,13 @@ export const treeRowReferenceDeleted = (proxy, path) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Lets a set of row reference created by
+ * gtk_tree_row_reference_new_proxy() know that the
+ * model emitted the ::row-inserted signal.
+ * @param proxy - a `GObject`
+ * @param path - the row position that was inserted
+ */
 export const treeRowReferenceInserted = (proxy, path) => {
     call("libgtk-4.so.1", "gtk_tree_row_reference_inserted", [
         {
@@ -1384,6 +2130,11 @@ export const treeRowReferenceInserted = (proxy, path) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Retrieves the `GtkExpression` stored inside the given `value`, and acquires
+ * a reference to it.
+ * @param value - a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+ */
 export const valueDupExpression = (value) => {
     const ptr = call("libgtk-4.so.1", "gtk_value_dup_expression", [
         {
@@ -1400,6 +2151,10 @@ export const valueDupExpression = (value) => {
         return null;
     return getObject(ptr, Expression);
 };
+/**
+ * Retrieves the `GtkExpression` stored inside the given `value`.
+ * @param value - a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+ */
 export const valueGetExpression = (value) => {
     const ptr = call("libgtk-4.so.1", "gtk_value_get_expression", [
         {
@@ -1416,6 +2171,13 @@ export const valueGetExpression = (value) => {
         return null;
     return getObject(ptr, Expression);
 };
+/**
+ * Stores the given `GtkExpression` inside `value`.
+ *
+ * The `GValue` will acquire a reference to the `expression`.
+ * @param value - a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+ * @param expression - a `GtkExpression`
+ */
 export const valueSetExpression = (value, expression) => {
     call("libgtk-4.so.1", "gtk_value_set_expression", [
         {
@@ -1433,6 +2195,13 @@ export const valueSetExpression = (value, expression) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Stores the given `GtkExpression` inside `value`.
+ *
+ * This function transfers the ownership of the `expression` to the `GValue`.
+ * @param value - a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+ * @param expression - a `GtkExpression`
+ */
 export const valueTakeExpression = (value, expression) => {
     call("libgtk-4.so.1", "gtk_value_take_expression", [
         {