@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/widget.js

@@ -13,6 +13,400 @@ import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import * as cairo from "../cairo/index.js";
+/**
+ * The base class for all widgets.
+ *
+ * It manages the widget lifecycle, layout, states and style.
+ *
+ * ### Height-for-width Geometry Management
+ *
+ * GTK uses a height-for-width (and width-for-height) geometry management
+ * system. Height-for-width means that a widget can change how much
+ * vertical space it needs, depending on the amount of horizontal space
+ * that it is given (and similar for width-for-height). The most common
+ * example is a label that reflows to fill up the available width, wraps
+ * to fewer lines, and therefore needs less height.
+ *
+ * Height-for-width geometry management is implemented in GTK by way
+ * of two virtual methods:
+ *
+ * - [vfunc@Gtk.Widget.get_request_mode]
+ * - [vfunc@Gtk.Widget.measure]
+ *
+ * There are some important things to keep in mind when implementing
+ * height-for-width and when using it in widget implementations.
+ *
+ * If you implement a direct `GtkWidget` subclass that supports
+ * height-for-width or width-for-height geometry management for itself
+ * or its child widgets, the [vfunc@Gtk.Widget.get_request_mode] virtual
+ * function must be implemented as well and return the widget's preferred
+ * request mode. The default implementation of this virtual function
+ * returns %GTK_SIZE_REQUEST_CONSTANT_SIZE, which means that the widget will
+ * only ever get -1 passed as the for_size value to its
+ * [vfunc@Gtk.Widget.measure] implementation.
+ *
+ * The geometry management system will query a widget hierarchy in
+ * only one orientation at a time. When widgets are initially queried
+ * for their minimum sizes it is generally done in two initial passes
+ * in the [enum@Gtk.SizeRequestMode] chosen by the toplevel.
+ *
+ * For example, when queried in the normal %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode:
+ *
+ * First, the default minimum and natural width for each widget
+ * in the interface will be computed using [method@Gtk.Widget.measure] with an
+ * orientation of %GTK_ORIENTATION_HORIZONTAL and a for_size of -1.
+ * Because the preferred widths for each widget depend on the preferred
+ * widths of their children, this information propagates up the hierarchy,
+ * and finally a minimum and natural width is determined for the entire
+ * toplevel. Next, the toplevel will use the minimum width to query for the
+ * minimum height contextual to that width using [method@Gtk.Widget.measure] with an
+ * orientation of %GTK_ORIENTATION_VERTICAL and a for_size of the just computed
+ * width. This will also be a highly recursive operation. The minimum height
+ * for the minimum width is normally used to set the minimum size constraint
+ * on the toplevel.
+ *
+ * After the toplevel window has initially requested its size in both
+ * dimensions it can go on to allocate itself a reasonable size (or a size
+ * previously specified with [method@Gtk.Window.set_default_size]). During the
+ * recursive allocation process it’s important to note that request cycles
+ * will be recursively executed while widgets allocate their children.
+ * Each widget, once allocated a size, will go on to first share the
+ * space in one orientation among its children and then request each child's
+ * height for its target allocated width or its width for allocated height,
+ * depending. In this way a widget will typically be requested its size
+ * a number of times before actually being allocated a size. The size a
+ * widget is finally allocated can of course differ from the size it has
+ * requested. For this reason, `GtkWidget` caches a  small number of results
+ * to avoid re-querying for the same sizes in one allocation cycle.
+ *
+ * If a widget does move content around to intelligently use up the
+ * allocated size then it must support the request in both
+ * `GtkSizeRequestMode`s even if the widget in question only
+ * trades sizes in a single orientation.
+ *
+ * For instance, a [class@Gtk.Label] that does height-for-width word wrapping
+ * will not expect to have [vfunc@Gtk.Widget.measure] with an orientation of
+ * %GTK_ORIENTATION_VERTICAL called because that call is specific to a
+ * width-for-height request. In this case the label must return the height
+ * required for its own minimum possible width. By following this rule any
+ * widget that handles height-for-width or width-for-height requests will
+ * always be allocated at least enough space to fit its own content.
+ *
+ * Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget
+ * generally deals with width-for-height requests:
+ *
+ * ```c
+ * static void
+ * foo_widget_measure (GtkWidget      *widget,
+ * GtkOrientation  orientation,
+ * int             for_size,
+ * int            *minimum_size,
+ * int            *natural_size,
+ * int            *minimum_baseline,
+ * int            *natural_baseline)
+ * {
+ * if (orientation == GTK_ORIENTATION_HORIZONTAL)
+ * {
+ * // Calculate minimum and natural width
+ * }
+ * else // VERTICAL
+ * {
+ * if (i_am_in_height_for_width_mode)
+ * {
+ * int min_width, dummy;
+ *
+ * // First, get the minimum width of our widget
+ * GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
+ * &min_width, &dummy, &dummy, &dummy);
+ *
+ * // Now use the minimum width to retrieve the minimum and natural height to display
+ * // that width.
+ * GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
+ * minimum_size, natural_size, &dummy, &dummy);
+ * }
+ * else
+ * {
+ * // ... some widgets do both.
+ * }
+ * }
+ * }
+ * ```
+ *
+ * Often a widget needs to get its own request during size request or
+ * allocation. For example, when computing height it may need to also
+ * compute width. Or when deciding how to use an allocation, the widget
+ * may need to know its natural size. In these cases, the widget should
+ * be careful to call its virtual methods directly, like in the code
+ * example above.
+ *
+ * It will not work to use the wrapper function [method@Gtk.Widget.measure]
+ * inside your own [vfunc@Gtk.Widget.size_allocate] implementation.
+ * These return a request adjusted by [class@Gtk.SizeGroup], the widget's
+ * align and expand flags, as well as its CSS style.
+ *
+ * If a widget used the wrappers inside its virtual method implementations,
+ * then the adjustments (such as widget margins) would be applied
+ * twice. GTK therefore does not allow this and will warn if you try
+ * to do it.
+ *
+ * Of course if you are getting the size request for another widget, such
+ * as a child widget, you must use [method@Gtk.Widget.measure]; otherwise, you
+ * would not properly consider widget margins, [class@Gtk.SizeGroup], and
+ * so forth.
+ *
+ * GTK also supports baseline vertical alignment of widgets. This
+ * means that widgets are positioned such that the typographical baseline of
+ * widgets in the same row are aligned. This happens if a widget supports
+ * baselines, has a vertical alignment using baselines, and is inside
+ * a widget that supports baselines and has a natural “row” that it aligns to
+ * the baseline, or a baseline assigned to it by the grandparent.
+ *
+ * Baseline alignment support for a widget is also done by the
+ * [vfunc@Gtk.Widget.measure] virtual function. It allows you to report
+ * both a minimum and natural size.
+ *
+ * If a widget ends up baseline aligned it will be allocated all the space in
+ * the parent as if it was %GTK_ALIGN_FILL, but the selected baseline can be
+ * found via [method@Gtk.Widget.get_baseline]. If the baseline has a
+ * value other than -1 you need to align the widget such that the baseline
+ * appears at the position.
+ *
+ * ### GtkWidget as GtkBuildable
+ *
+ * The `GtkWidget` implementation of the `GtkBuildable` interface
+ * supports various custom elements to specify additional aspects of widgets
+ * that are not directly expressed as properties.
+ *
+ * If the widget uses a [class@Gtk.LayoutManager], `GtkWidget` supports
+ * a custom `<layout>` element, used to define layout properties:
+ *
+ * ```xml
+ * <object class="GtkGrid" id="my_grid">
+ * <child>
+ * <object class="GtkLabel" id="label1">
+ * <property name="label">Description</property>
+ * <layout>
+ * <property name="column">0</property>
+ * <property name="row">0</property>
+ * <property name="row-span">1</property>
+ * <property name="column-span">1</property>
+ * </layout>
+ * </object>
+ * </child>
+ * <child>
+ * <object class="GtkEntry" id="description_entry">
+ * <layout>
+ * <property name="column">1</property>
+ * <property name="row">0</property>
+ * <property name="row-span">1</property>
+ * <property name="column-span">1</property>
+ * </layout>
+ * </object>
+ * </child>
+ * </object>
+ * ```
+ *
+ * `GtkWidget` allows style information such as style classes to
+ * be associated with widgets, using the custom `<style>` element:
+ *
+ * ```xml
+ * <object class="GtkButton" id="button1">
+ * <style>
+ * <class name="my-special-button-class"/>
+ * <class name="dark-button"/>
+ * </style>
+ * </object>
+ * ```
+ *
+ * `GtkWidget` allows defining accessibility information, such as properties,
+ * relations, and states, using the custom `<accessibility>` element:
+ *
+ * ```xml
+ * <object class="GtkButton" id="button1">
+ * <accessibility>
+ * <property name="label">Download</property>
+ * <relation name="labelled-by">label1</relation>
+ * </accessibility>
+ * </object>
+ * ```
+ *
+ * ### Building composite widgets from template XML
+ *
+ * `GtkWidget `exposes some facilities to automate the procedure
+ * of creating composite widgets using "templates".
+ *
+ * To create composite widgets with `GtkBuilder` XML, one must associate
+ * the interface description with the widget class at class initialization
+ * time using [method@Gtk.WidgetClass.set_template].
+ *
+ * The interface description semantics expected in composite template descriptions
+ * is slightly different from regular [class@Gtk.Builder] XML.
+ *
+ * Unlike regular interface descriptions, [method@Gtk.WidgetClass.set_template]
+ * will expect a `<template>` tag as a direct child of the toplevel
+ * `<interface>` tag. The `<template>` tag must specify the “class” attribute
+ * which must be the type name of the widget. Optionally, the “parent”
+ * attribute may be specified to specify the direct parent type of the widget
+ * type; this is ignored by `GtkBuilder` but can be used by UI design tools to
+ * introspect what kind of properties and internal children exist for a given
+ * type when the actual type does not exist.
+ *
+ * The XML which is contained inside the `<template>` tag behaves as if it were
+ * added to the `<object>` tag defining the widget itself. You may set properties
+ * on a widget by inserting `<property>` tags into the `<template>` tag, and also
+ * add `<child>` tags to add children and extend a widget in the normal way you
+ * would with `<object>` tags.
+ *
+ * Additionally, `<object>` tags can also be added before and after the initial
+ * `<template>` tag in the normal way, allowing one to define auxiliary objects
+ * which might be referenced by other widgets declared as children of the
+ * `<template>` tag.
+ *
+ * Since, unlike the `<object>` tag, the `<template>` tag does not contain an
+ * “id” attribute, if you need to refer to the instance of the object itself that
+ * the template will create, simply refer to the template class name in an
+ * applicable element content.
+ *
+ * Here is an example of a template definition, which includes an example of
+ * this in the `<signal>` tag:
+ *
+ * ```xml
+ * <interface>
+ * <template class="FooWidget" parent="GtkBox">
+ * <property name="orientation">horizontal</property>
+ * <property name="spacing">4</property>
+ * <child>
+ * <object class="GtkButton" id="hello_button">
+ * <property name="label">Hello World</property>
+ * <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
+ * </object>
+ * </child>
+ * <child>
+ * <object class="GtkButton" id="goodbye_button">
+ * <property name="label">Goodbye World</property>
+ * </object>
+ * </child>
+ * </template>
+ * </interface>
+ * ```
+ *
+ * Typically, you'll place the template fragment into a file that is
+ * bundled with your project, using `GResource`. In order to load the
+ * template, you need to call [method@Gtk.WidgetClass.set_template_from_resource]
+ * from the class initialization of your `GtkWidget` type:
+ *
+ * ```c
+ * static void
+ * foo_widget_class_init (FooWidgetClass *klass)
+ * {
+ * // ...
+ *
+ * gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+ * "/com/example/ui/foowidget.ui");
+ * }
+ * ```
+ *
+ * You will also need to call [method@Gtk.Widget.init_template] from the
+ * instance initialization function:
+ *
+ * ```c
+ * static void
+ * foo_widget_init (FooWidget *self)
+ * {
+ * gtk_widget_init_template (GTK_WIDGET (self));
+ *
+ * // Initialize the rest of the widget...
+ * }
+ * ```
+ *
+ * as well as calling [method@Gtk.Widget.dispose_template] from the dispose
+ * function:
+ *
+ * ```c
+ * static void
+ * foo_widget_dispose (GObject *gobject)
+ * {
+ * FooWidget *self = FOO_WIDGET (gobject);
+ *
+ * // Dispose objects for which you have a reference...
+ *
+ * // Clear the template children for this widget type
+ * gtk_widget_dispose_template (GTK_WIDGET (self), FOO_TYPE_WIDGET);
+ *
+ * G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
+ * }
+ * ```
+ *
+ * You can access widgets defined in the template using the
+ * [method@Gtk.Widget.get_template_child] function, but you will typically declare
+ * a pointer in the instance private data structure of your type using the same
+ * name as the widget in the template definition, and call
+ * [method@Gtk.WidgetClass.bind_template_child_full] (or one of its wrapper macros
+ * [func@Gtk.widget_class_bind_template_child] and [func@Gtk.widget_class_bind_template_child_private])
+ * with that name, e.g.
+ *
+ * ```c
+ * typedef struct {
+ * GtkWidget *hello_button;
+ * GtkWidget *goodbye_button;
+ * } FooWidgetPrivate;
+ *
+ * G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)
+ *
+ * static void
+ * foo_widget_dispose (GObject *gobject)
+ * {
+ * gtk_widget_dispose_template (GTK_WIDGET (gobject), FOO_TYPE_WIDGET);
+ *
+ * G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
+ * }
+ *
+ * static void
+ * foo_widget_class_init (FooWidgetClass *klass)
+ * {
+ * // ...
+ * G_OBJECT_CLASS (klass)->dispose = foo_widget_dispose;
+ *
+ * gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+ * "/com/example/ui/foowidget.ui");
+ * gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
+ * FooWidget, hello_button);
+ * gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
+ * FooWidget, goodbye_button);
+ * }
+ *
+ * static void
+ * foo_widget_init (FooWidget *widget)
+ * {
+ * gtk_widget_init_template (GTK_WIDGET (widget));
+ * }
+ * ```
+ *
+ * You can also use [method@Gtk.WidgetClass.bind_template_callback_full] (or
+ * is wrapper macro [func@Gtk.widget_class_bind_template_callback]) to connect
+ * a signal callback defined in the template with a function visible in the
+ * scope of the class, e.g.
+ *
+ * ```c
+ * // the signal handler has the instance and user data swapped
+ * // because of the swapped="yes" attribute in the template XML
+ * static void
+ * hello_button_clicked (FooWidget *self,
+ * GtkButton *button)
+ * {
+ * g_print ("Hello, world!\n");
+ * }
+ *
+ * static void
+ * foo_widget_class_init (FooWidgetClass *klass)
+ * {
+ * // ...
+ * gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+ * "/com/example/ui/foowidget.ui");
+ * gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
+ * }
+ * ```
+ */
 const SIGNAL_META = {
     destroy: { params: [], returnType: { type: "undefined" } },
     "direction-changed": {
@@ -66,6 +460,11 @@ export class Widget extends GObject.InitiallyUnowned {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Obtains the default reading direction.
+     *
+     * See [func@Gtk.Widget.set_default_direction].
+     */
     static getDefaultDirection() {
         return call("libgtk-4.so.1", "gtk_widget_get_default_direction", [], {
             type: "int",
@@ -73,6 +472,12 @@ export class Widget extends GObject.InitiallyUnowned {
             unsigned: false,
         });
     }
+    /**
+     * Sets the default reading direction for widgets.
+     *
+     * See [method@Gtk.Widget.set_direction].
+     * @param dir - the new default direction, either [enum@Gtk.TextDirection.ltr]
+     */
     static setDefaultDirection(dir) {
         call("libgtk-4.so.1", "gtk_widget_set_default_direction", [
             {
@@ -81,6 +486,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Enables or disables an action installed with
+     * [method@Gtk.WidgetClass.install_action].
+     * @param actionName - action name, such as "clipboard.paste"
+     * @param enabled - whether the action is now enabled
+     */
     actionSetEnabled(actionName, enabled) {
         call("libgtk-4.so.1", "gtk_widget_action_set_enabled", [
             {
@@ -97,6 +508,22 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Activates the widget.
+     *
+     * The activation will emit the signal set using
+     * [method@Gtk.WidgetClass.set_activate_signal]
+     * during class initialization.
+     *
+     * Activation is what happens when you press `Enter`
+     * on a widget.
+     *
+     * If you wish to handle the activation keybinding yourself,
+     * it is recommended to use [method@Gtk.WidgetClass.add_shortcut]
+     * with an action created with [ctor@Gtk.SignalAction.new].
+     *
+     * If `widget` is not activatable, the function returns false.
+     */
     activate() {
         return call("libgtk-4.so.1", "gtk_widget_activate", [
             {
@@ -105,6 +532,22 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Activates an action for the widget.
+     *
+     * The action is looked up in the action groups associated with
+     * `widget` and its ancestors.
+     *
+     * If the action is in an action group added with
+     * [method@Gtk.Widget.insert_action_group], the `name` is expected
+     * to be prefixed with the prefix that was used when the group was
+     * inserted.
+     *
+     * The arguments must match the actions expected parameter type,
+     * as returned by [method@Gio.Action.get_parameter_type].
+     * @param name - the name of the action to activate
+     * @param args - parameters to use
+     */
     activateActionVariant(name, args) {
         return call("libgtk-4.so.1", "gtk_widget_activate_action_variant", [
             {
@@ -127,6 +570,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Activates the `default.activate` action for the widget.
+     *
+     * The action is looked up in the same was as for
+     * [method@Gtk.Widget.activate_action].
+     */
     activateDefault() {
         call("libgtk-4.so.1", "gtk_widget_activate_default", [
             {
@@ -135,6 +584,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds an event controller to the widget.
+     *
+     * The event controllers of a widget handle the events that are
+     * propagated to the widget.
+     *
+     * You will usually want to call this function right after
+     * creating any kind of [class@Gtk.EventController].
+     * @param controller - an event controller that hasn't been
+     */
     addController(controller) {
         call("libgtk-4.so.1", "gtk_widget_add_controller", [
             {
@@ -147,6 +606,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a style class to the widget.
+     *
+     * After calling this function, the widget’s style will match
+     * for @css_class, according to CSS matching rules.
+     *
+     * Use [method@Gtk.Widget.remove_css_class] to remove the
+     * style again.
+     * @param cssClass - style class to add to @widget, without the leading period
+     */
     addCssClass(cssClass) {
         call("libgtk-4.so.1", "gtk_widget_add_css_class", [
             {
@@ -159,6 +628,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Adds a widget to the list of mnemonic labels for this widget.
+     *
+     * See [method@Gtk.Widget.list_mnemonic_labels].
+     *
+     * Note that the list of mnemonic labels for the widget is cleared
+     * when the widget is destroyed, so the caller must make sure
+     * to update its internal state at this point as well.
+     * @param label - a widget that acts as a mnemonic label for @widget
+     */
     addMnemonicLabel(label) {
         call("libgtk-4.so.1", "gtk_widget_add_mnemonic_label", [
             {
@@ -171,6 +650,37 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Queues an animation frame update and adds a callback to be called
+     * before each frame.
+     *
+     * Until the tick callback is removed, it will be called frequently
+     * (usually at the frame rate of the output device or as quickly as
+     * the application can be repainted, whichever is slower). For this
+     * reason, is most suitable for handling graphics that change every
+     * frame or every few frames.
+     *
+     * The tick callback does not automatically imply a relayout or repaint.
+     * If you want a repaint or relayout, and aren’t changing widget properties
+     * that would trigger that (for example, changing the text of a label),
+     * then you will have to call [method@Gtk.Widget.queue_resize] or
+     * [method@Gtk.Widget.queue_draw] yourself.
+     *
+     * [method@Gdk.FrameClock.get_frame_time] should generally be used
+     * for timing continuous animations and
+     * [method@Gdk.FrameTimings.get_predicted_presentation_time] should be
+     * used if you are trying to display isolated frames at particular times.
+     *
+     * This is a more convenient alternative to connecting directly to the
+     * [signal@Gdk.FrameClock::update] signal of the frame clock, since you
+     * don't have to worry about when a frame clock is assigned to a widget.
+     *
+     * To remove a tick callback, pass the ID that is returned by this function
+     * to [method@Gtk.Widget.remove_tick_callback].
+     * @param callback - function
+     * @param userData - data to pass to @callback
+     * @param notify - function to call to free @user_data
+     */
     addTickCallback(callback, notify, userData) {
         return call("libgtk-4.so.1", "gtk_widget_add_tick_callback", [
             {
@@ -192,6 +702,23 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Assigns size, position, (optionally) a baseline and transform
+     * to a child widget.
+     *
+     * In this function, the allocation and baseline may be adjusted.
+     * The given allocation will be forced to be bigger than the
+     * widget's minimum size, as well as at least 0×0 in size.
+     *
+     * This function is only used by widget implementations.
+     *
+     * For a version that does not take a transform, see
+     * [method@Gtk.Widget.size_allocate].
+     * @param width - new width
+     * @param height - new height
+     * @param baseline - new baseline, or -1
+     * @param transform - transformation to be applied
+     */
     allocate(width, height, baseline, transform) {
         call("libgtk-4.so.1", "gtk_widget_allocate", [
             {
@@ -221,6 +748,29 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Called by widgets as the user moves around the window using
+     * keyboard shortcuts.
+     *
+     * The `direction` argument indicates what kind of motion is taking
+     * place (up, down, left, right, tab forward, tab backward).
+     *
+     * This function calls the [vfunc@Gtk.Widget.focus] virtual function;
+     * widgets can override the virtual function in order to implement
+     * appropriate focus behavior.
+     *
+     * The default `focus()` virtual function for a widget should return
+     * true if moving in `direction` left the focus on a focusable location
+     * inside that widget, and false if moving in `direction` moved the focus
+     * outside the widget. When returning true, widgets normally call
+     * [method@Gtk.Widget.grab_focus] to place the focus accordingly;
+     * when returning false, they don’t modify the current focus location.
+     *
+     * This function is used by custom widget implementations; if you're
+     * writing an app, you’d use [method@Gtk.Widget.grab_focus] to move
+     * the focus to a particular widget.
+     * @param direction - direction of focus movement
+     */
     childFocus(direction) {
         return call("libgtk-4.so.1", "gtk_widget_child_focus", [
             {
@@ -233,6 +783,22 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Computes the bounds for `widget` in the coordinate space of @target.
+     *
+     * The bounds of widget are (the bounding box of) the region that it is
+     * expected to draw in. See the coordinate system
+     * overview to learn more.
+     *
+     * If the operation is successful, true is returned. If `widget` has no
+     * bounds or the bounds cannot be expressed in @target's coordinate space
+     * (for example if both widgets are in different windows), false is
+     * returned and `bounds` is set to the zero rectangle.
+     *
+     * It is valid for `widget` and `target` to be the same widget.
+     * @param target - the target widget
+     * @param outBounds - the rectangle taking the bounds
+     */
     computeBounds(target, outBounds) {
         return call("libgtk-4.so.1", "gtk_widget_compute_bounds", [
             {
@@ -256,6 +822,22 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Computes whether a parent widget should give this widget
+     * extra space when possible.
+     *
+     * Widgets with children should check this, rather than looking at
+     * [method@Gtk.Widget.get_hexpand] or [method@Gtk.Widget.get_vexpand].
+     *
+     * This function already checks whether the widget is visible, so
+     * visibility does not need to be checked separately. Non-visible
+     * widgets are not expanded.
+     *
+     * The computed expand value uses either the expand setting explicitly
+     * set on the widget itself, or, if none has been explicitly set,
+     * the widget may expand if some of its children do.
+     * @param orientation - expand direction
+     */
     computeExpand(orientation) {
         return call("libgtk-4.so.1", "gtk_widget_compute_expand", [
             {
@@ -268,6 +850,17 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Translates the given `point` in @widget's coordinates to coordinates
+     * in @target’s coordinate system.
+     *
+     * In order to perform this operation, both widgets must share a
+     * a common ancestor. If that is not the case, `out_point` is set
+     * to (0, 0) and false is returned.
+     * @param target - the widget to transform into
+     * @param point - a point in @widget's coordinate system
+     * @param outPoint - set to the corresponding coordinates in
+     */
     computePoint(target, point, outPoint) {
         return call("libgtk-4.so.1", "gtk_widget_compute_point", [
             {
@@ -300,6 +893,19 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Computes a matrix suitable to describe a transformation from
+     * @widget's coordinate system into @target's coordinate system.
+     *
+     * The transform can not be computed in certain cases, for example
+     * when `widget` and `target` do not share a common ancestor. In that
+     * case `out_transform` gets set to the identity matrix.
+     *
+     * To learn more about widget coordinate systems, see the coordinate
+     * system overview.
+     * @param target - the target widget that the matrix will transform to
+     * @param outTransform - location to
+     */
     computeTransform(target, outTransform) {
         return call("libgtk-4.so.1", "gtk_widget_compute_transform", [
             {
@@ -323,6 +929,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Tests if a given point is contained in the widget.
+     *
+     * The coordinates for (x, y) must be in widget coordinates, so
+     * (0, 0) is assumed to be the top left of @widget's content area.
+     * @param x - X coordinate to test, relative to @widget's origin
+     * @param y - Y coordinate to test, relative to @widget's origin
+     */
     contains(x, y) {
         return call("libgtk-4.so.1", "gtk_widget_contains", [
             {
@@ -339,6 +953,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Creates a new `PangoContext` that is configured for the widget.
+     *
+     * The `PangoContext` will have the appropriate font map,
+     * font options, font description, and base direction set.
+     *
+     * See also [method@Gtk.Widget.get_pango_context].
+     */
     createPangoContext() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_create_pango_context", [
             {
@@ -348,6 +970,18 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Pango.Context);
     }
+    /**
+     * Creates a new `PangoLayout` that is configured for the widget.
+     *
+     * The `PangoLayout` will have the appropriate font map,
+     * font description, and base direction set.
+     *
+     * If you keep a `PangoLayout` created in this way around,
+     * you need to re-create it when the widgets `PangoContext`
+     * is replaced. This can be tracked by listening to changes
+     * of the [property@Gtk.Widget:root] property on the widget.
+     * @param text - text to set on the layout
+     */
     createPangoLayout(text) {
         const ptr = call("libgtk-4.so.1", "gtk_widget_create_pango_layout", [
             {
@@ -362,6 +996,34 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Pango.Layout);
     }
+    /**
+     * Clears the template children for the widget.
+     *
+     * This function is the opposite of [method@Gtk.Widget.init_template],
+     * and it is used to clear all the template children from a widget
+     * instance. If you bound a template child to a field in the instance
+     * structure, or in the instance private data structure, the field will
+     * be set to `NULL` after this function returns.
+     *
+     * You should call this function inside the `GObjectClass.dispose()`
+     * implementation of any widget that called [method@Gtk.Widget.init_template].
+     * Typically, you will want to call this function last, right before
+     * chaining up to the parent type's dispose implementation, e.g.
+     *
+     * ```c
+     * static void
+     * some_widget_dispose (GObject *gobject)
+     * {
+     * SomeWidget *self = SOME_WIDGET (gobject);
+     *
+     * // Clear the template data for SomeWidget
+     * gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+     *
+     * G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+     * }
+     * ```
+     * @param widgetType - the type of the widget to finalize the template for
+     */
     disposeTemplate(widgetType) {
         call("libgtk-4.so.1", "gtk_widget_dispose_template", [
             {
@@ -374,6 +1036,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks to see if a drag movement has passed the GTK drag threshold.
+     * @param startX - X coordinate of start of drag
+     * @param startY - Y coordinate of start of drag
+     * @param currentX - current X coordinate
+     * @param currentY - current Y coordinate
+     */
     dragCheckThreshold(startX, startY, currentX, currentY) {
         return call("libgtk-4.so.1", "gtk_drag_check_threshold", [
             {
@@ -398,6 +1067,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Notifies the user about an input-related error on the widget.
+     *
+     * If the [property@Gtk.Settings:gtk-error-bell] setting is true,
+     * it calls [method@Gdk.Surface.beep], otherwise it does nothing.
+     *
+     * Note that the effect of [method@Gdk.Surface.beep] can be configured
+     * in many ways, depending on the windowing backend and the desktop
+     * environment or window manager that is used.
+     */
     errorBell() {
         call("libgtk-4.so.1", "gtk_widget_error_bell", [
             {
@@ -406,6 +1085,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the baseline that has currently been allocated to the widget.
+     *
+     * This function is intended to be used when implementing handlers
+     * for the `GtkWidget`Class.snapshot() function, and when allocating
+     * child widgets in `GtkWidget`Class.size_allocate().
+     */
     getAllocatedBaseline() {
         return call("libgtk-4.so.1", "gtk_widget_get_allocated_baseline", [
             {
@@ -414,6 +1100,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the height that has currently been allocated to the widget.
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     */
     getAllocatedHeight() {
         return call("libgtk-4.so.1", "gtk_widget_get_allocated_height", [
             {
@@ -422,6 +1114,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the width that has currently been allocated to the widget.
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     */
     getAllocatedWidth() {
         return call("libgtk-4.so.1", "gtk_widget_get_allocated_width", [
             {
@@ -430,6 +1128,24 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the widget’s allocation.
+     *
+     * Note, when implementing a layout widget: a widget’s allocation
+     * will be its “adjusted” allocation, that is, the widget’s parent
+     * typically calls [method@Gtk.Widget.size_allocate] with an allocation,
+     * and that allocation is then adjusted (to handle margin
+     * and alignment for example) before assignment to the widget.
+     * [method@Gtk.Widget.get_allocation] returns the adjusted allocation that
+     * was actually assigned to the widget. The adjusted allocation is
+     * guaranteed to be completely contained within the
+     * [method@Gtk.Widget.size_allocate] allocation, however.
+     *
+     * So a layout widget is guaranteed that its children stay inside
+     * the assigned bounds, but not that they have exactly the bounds the
+     * widget assigned.
+     * @param allocation - a pointer to a `GtkAllocation` to copy to
+     */
     getAllocation(allocation) {
         call("libgtk-4.so.1", "gtk_widget_get_allocation", [
             {
@@ -445,6 +1161,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the first ancestor of the widget with type @widget_type.
+     *
+     * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+     * gets the first `GtkBox` that’s an ancestor of @widget. No
+     * reference will be added to the returned widget; it should
+     * not be unreferenced.
+     *
+     * Note that unlike [method@Gtk.Widget.is_ancestor], this function
+     * considers `widget` to be an ancestor of itself.
+     * @param widgetType - ancestor type
+     */
     getAncestor(widgetType) {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_ancestor", [
             {
@@ -460,6 +1188,13 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns the baseline that has currently been allocated to the widget.
+     *
+     * This function is intended to be used when implementing handlers
+     * for the `GtkWidgetClass.snapshot()` function, and when allocating
+     * child widgets in `GtkWidgetClass.size_allocate()`.
+     */
     getBaseline() {
         return call("libgtk-4.so.1", "gtk_widget_get_baseline", [
             {
@@ -468,6 +1203,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Determines whether the input focus can enter the widget or any
+     * of its children.
+     *
+     * See [method@Gtk.Widget.set_can_focus].
+     */
     getCanFocus() {
         return call("libgtk-4.so.1", "gtk_widget_get_can_focus", [
             {
@@ -476,6 +1217,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Queries whether the widget can be the target of pointer events.
+     */
     getCanTarget() {
         return call("libgtk-4.so.1", "gtk_widget_get_can_target", [
             {
@@ -484,6 +1228,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the value set with [method@Gtk.Widget.set_child_visible].
+     *
+     * If you feel a need to use this function, your code probably
+     * needs reorganization.
+     *
+     * This function is only useful for widget implementations
+     * and should never be called by an application.
+     */
     getChildVisible() {
         return call("libgtk-4.so.1", "gtk_widget_get_child_visible", [
             {
@@ -492,6 +1245,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the clipboard object for the widget.
+     *
+     * This is a utility function to get the clipboard object for the
+     * display that `widget` is using.
+     *
+     * Note that this function always works, even when `widget` is not
+     * realized yet.
+     */
     getClipboard() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_clipboard", [
             {
@@ -501,6 +1263,14 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gdk.Clipboard);
     }
+    /**
+     * Gets the current foreground color for the widget’s style.
+     *
+     * This function should only be used in snapshot
+     * implementations that need to do custom drawing
+     * with the foreground color.
+     * @param color - return location for the color
+     */
     getColor(color) {
         call("libgtk-4.so.1", "gtk_widget_get_color", [
             {
@@ -520,6 +1290,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the list of style classes applied to the widget.
+     */
     getCssClasses() {
         return call("libgtk-4.so.1", "gtk_widget_get_css_classes", [
             {
@@ -528,6 +1301,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Returns the CSS name of the widget.
+     */
     getCssName() {
         return call("libgtk-4.so.1", "gtk_widget_get_css_name", [
             {
@@ -536,6 +1312,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the cursor set on the widget.
+     *
+     * See [method@Gtk.Widget.set_cursor] for details.
+     */
     getCursor() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_cursor", [
             {
@@ -547,6 +1328,11 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Gdk.Cursor);
     }
+    /**
+     * Gets the reading direction for the widget.
+     *
+     * See [method@Gtk.Widget.set_direction].
+     */
     getDirection() {
         return call("libgtk-4.so.1", "gtk_widget_get_direction", [
             {
@@ -555,6 +1341,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Get the display for the window that the widget belongs to.
+     *
+     * This function can only be called after the widget has been
+     * added to a widget hierarchy with a `GtkRoot` at the top.
+     *
+     * In general, you should only create display-specific
+     * resources when a widget has been realized, and you should
+     * free those resources when the widget is unrealized.
+     */
     getDisplay() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_display", [
             {
@@ -564,6 +1360,11 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gdk.Display);
     }
+    /**
+     * Returns the widget’s first child.
+     *
+     * This function is primarily meant for widget implementations.
+     */
     getFirstChild() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_first_child", [
             {
@@ -575,6 +1376,9 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns the focus child of the widget.
+     */
     getFocusChild() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_focus_child", [
             {
@@ -586,6 +1390,12 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Returns whether the widget should grab focus when it is clicked
+     * with the mouse.
+     *
+     * See [method@Gtk.Widget.set_focus_on_click].
+     */
     getFocusOnClick() {
         return call("libgtk-4.so.1", "gtk_widget_get_focus_on_click", [
             {
@@ -594,6 +1404,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether the widget can own the input focus.
+     *
+     * See [method@Gtk.Widget.set_focusable].
+     */
     getFocusable() {
         return call("libgtk-4.so.1", "gtk_widget_get_focusable", [
             {
@@ -602,6 +1417,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the font map of the widget.
+     *
+     * See [method@Gtk.Widget.set_font_map].
+     */
     getFontMap() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_font_map", [
             {
@@ -613,6 +1433,11 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Pango.FontMap);
     }
+    /**
+     * Returns the `cairo_font_options_t` of the widget.
+     *
+     * Seee [method@Gtk.Widget.set_font_options].
+     */
     getFontOptions() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_font_options", [
             {
@@ -629,6 +1454,30 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, cairo.FontOptions);
     }
+    /**
+     * Obtains the frame clock for a widget.
+     *
+     * The frame clock is a global “ticker” that can be used to drive
+     * animations and repaints. The most common reason to get the frame
+     * clock is to call [method@Gdk.FrameClock.get_frame_time], in order
+     * to get a time to use for animating. For example you might record
+     * the start of the animation with an initial value from
+     * [method@Gdk.FrameClock.get_frame_time], and then update the animation
+     * by calling [method@Gdk.FrameClock.get_frame_time] again during each repaint.
+     *
+     * [method@Gdk.FrameClock.request_phase] will result in a new frame on the
+     * clock, but won’t necessarily repaint any widgets. To repaint a widget,
+     * you have to use [method@Gtk.Widget.queue_draw] which invalidates the
+     * widget (thus scheduling it to receive a draw on the next frame).
+     * [method@Gtk.Widget.queue_draw] will also end up requesting a frame
+     * on the appropriate frame clock.
+     *
+     * A widget’s frame clock will not change while the widget is mapped.
+     * Reparenting a widget (which implies a temporary unmap) can change
+     * the widget’s frame clock.
+     *
+     * Unrealized widgets do not have a frame clock.
+     */
     getFrameClock() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_frame_clock", [
             {
@@ -640,6 +1489,15 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Gdk.FrameClock);
     }
+    /**
+     * Gets the horizontal alignment of the widget.
+     *
+     * For backwards compatibility reasons this method will never return
+     * one of the baseline alignments, but instead it will convert it to
+     * [enum@Gtk.Align.fill] or [enum@Gtk.Align.center].
+     *
+     * Baselines are not supported for horizontal alignment.
+     */
     getHalign() {
         return call("libgtk-4.so.1", "gtk_widget_get_halign", [
             {
@@ -648,6 +1506,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the current value of the `has-tooltip` property.
+     */
     getHasTooltip() {
         return call("libgtk-4.so.1", "gtk_widget_get_has_tooltip", [
             {
@@ -656,6 +1517,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the content height of the widget.
+     *
+     * This function returns the height passed to its
+     * size-allocate implementation, which is the height you
+     * should be using in [vfunc@Gtk.Widget.snapshot].
+     *
+     * For pointer events, see [method@Gtk.Widget.contains].
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     */
     getHeight() {
         return call("libgtk-4.so.1", "gtk_widget_get_height", [
             {
@@ -664,6 +1537,23 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets whether the widget would like any available extra horizontal
+     * space.
+     *
+     * When a user resizes a window, widgets with expand set to true generally
+     * receive the extra space. For example, a list or scrollable area
+     * or document in your window would often be set to expand.
+     *
+     * Widgets with children should use [method@Gtk.Widget.compute_expand]
+     * rather than this function, to see whether any of its children,
+     * has the expand flag set. If any child of a widget wants to
+     * expand, the parent may ask to expand also.
+     *
+     * This function only looks at the widget’s own hexpand flag, rather
+     * than computing whether the entire widget tree rooted at this widget
+     * wants to expand.
+     */
     getHexpand() {
         return call("libgtk-4.so.1", "gtk_widget_get_hexpand", [
             {
@@ -672,6 +1562,17 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether the `hexpand` flag has been explicitly set.
+     *
+     * If [property@Gtk.Widget:hexpand] property is set, then it
+     * overrides any computed expand value based on child widgets.
+     * If `hexpand` is not set, then the expand value depends on
+     * whether any children of the widget would like to expand.
+     *
+     * There are few reasons to use this function, but it’s here
+     * for completeness and consistency.
+     */
     getHexpandSet() {
         return call("libgtk-4.so.1", "gtk_widget_get_hexpand_set", [
             {
@@ -680,6 +1581,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the widget’s last child.
+     *
+     * This function is primarily meant for widget implementations.
+     */
     getLastChild() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_last_child", [
             {
@@ -691,6 +1597,11 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Retrieves the layout manager of the widget.
+     *
+     * See [method@Gtk.Widget.set_layout_manager].
+     */
     getLayoutManager() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_layout_manager", [
             {
@@ -702,6 +1613,9 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, LayoutManager);
     }
+    /**
+     * Gets the value of the [property@Gtk.Widget:limit-events] property.
+     */
     getLimitEvents() {
         return call("libgtk-4.so.1", "gtk_widget_get_limit_events", [
             {
@@ -710,6 +1624,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the widget is mapped.
+     */
     getMapped() {
         return call("libgtk-4.so.1", "gtk_widget_get_mapped", [
             {
@@ -718,6 +1635,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the bottom margin of the widget.
+     */
     getMarginBottom() {
         return call("libgtk-4.so.1", "gtk_widget_get_margin_bottom", [
             {
@@ -726,6 +1646,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the end margin of the widget.
+     */
     getMarginEnd() {
         return call("libgtk-4.so.1", "gtk_widget_get_margin_end", [
             {
@@ -734,6 +1657,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the start margin of the widget.
+     */
     getMarginStart() {
         return call("libgtk-4.so.1", "gtk_widget_get_margin_start", [
             {
@@ -742,6 +1668,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the top margin of the widget.
+     */
     getMarginTop() {
         return call("libgtk-4.so.1", "gtk_widget_get_margin_top", [
             {
@@ -750,6 +1679,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the name of a widget.
+     *
+     * See [method@Gtk.Widget.set_name] for the significance of widget names.
+     */
     getName() {
         return call("libgtk-4.so.1", "gtk_widget_get_name", [
             {
@@ -758,6 +1692,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Returns the nearest `GtkNative` ancestor of the widget.
+     *
+     * This function will return `NULL` if the widget is not
+     * contained inside a widget tree with a native ancestor.
+     *
+     * `GtkNative` widgets will return themselves here.
+     */
     getNative() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_native", [
             {
@@ -769,6 +1711,11 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Native);
     }
+    /**
+     * Returns the widget’s next sibling.
+     *
+     * This function is primarily meant for widget implementations.
+     */
     getNextSibling() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_next_sibling", [
             {
@@ -780,6 +1727,11 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Fetches the requested opacity for the widget.
+     *
+     * See [method@Gtk.Widget.set_opacity].
+     */
     getOpacity() {
         return call("libgtk-4.so.1", "gtk_widget_get_opacity", [
             {
@@ -788,6 +1740,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "float", size: 64 });
     }
+    /**
+     * Returns the widget’s overflow value.
+     */
     getOverflow() {
         return call("libgtk-4.so.1", "gtk_widget_get_overflow", [
             {
@@ -796,6 +1751,19 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets a `PangoContext` that is configured for the widget.
+     *
+     * The `PangoContext` will have the appropriate font map, font description,
+     * and base direction set.
+     *
+     * Unlike the context returned by [method@Gtk.Widget.create_pango_context],
+     * this context is owned by the widget (it can be used until the screen
+     * for the widget changes or the widget is removed from its toplevel),
+     * and will be updated to match any changes to the widget’s attributes.
+     * This can be tracked by listening to changes of the
+     * [property@Gtk.Widget:root] property on the widget.
+     */
     getPangoContext() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_pango_context", [
             {
@@ -805,6 +1773,9 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Pango.Context);
     }
+    /**
+     * Returns the parent widget of the widget.
+     */
     getParent() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_parent", [
             {
@@ -816,6 +1787,24 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Retrieves the minimum and natural size of a widget, taking
+     * into account the widget’s preference for height-for-width management.
+     *
+     * This is used to retrieve a suitable size by container widgets which do
+     * not impose any restrictions on the child placement. It can be used
+     * to deduce toplevel window and menu sizes as well as child widgets in
+     * free-form containers such as `GtkFixed`.
+     *
+     * Handle with care. Note that the natural height of a height-for-width
+     * widget will generally be a smaller size than the minimum height, since
+     * the required height for the natural width is generally smaller than the
+     * required height for the minimum width.
+     *
+     * Use [method@Gtk.Widget.measure] if you want to support baseline alignment.
+     * @param minimumSize - location for storing the minimum size
+     * @param naturalSize - location for storing the natural size
+     */
     getPreferredSize(minimumSize, naturalSize) {
         call("libgtk-4.so.1", "gtk_widget_get_preferred_size", [
             {
@@ -848,6 +1837,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the widget’s previous sibling.
+     *
+     * This function is primarily meant for widget implementations.
+     */
     getPrevSibling() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_prev_sibling", [
             {
@@ -859,6 +1853,15 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets the primary clipboard of the widget.
+     *
+     * This is a utility function to get the primary clipboard object
+     * for the display that `widget` is using.
+     *
+     * Note that this function always works, even when `widget` is not
+     * realized yet.
+     */
     getPrimaryClipboard() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_primary_clipboard", [
             {
@@ -868,6 +1871,9 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gdk.Clipboard);
     }
+    /**
+     * Determines whether the widget is realized.
+     */
     getRealized() {
         return call("libgtk-4.so.1", "gtk_widget_get_realized", [
             {
@@ -876,6 +1882,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether the widget is always treated as the default widget
+     * within its toplevel when it has the focus, even if another widget
+     * is the default.
+     *
+     * See [method@Gtk.Widget.set_receives_default].
+     */
     getReceivesDefault() {
         return call("libgtk-4.so.1", "gtk_widget_get_receives_default", [
             {
@@ -884,6 +1897,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether the widget prefers a height-for-width layout
+     * or a width-for-height layout.
+     *
+     * Single-child widgets generally propagate the preference of
+     * their child, more complex widgets need to request something
+     * either in context of their children or in context of their
+     * allocation capabilities.
+     */
     getRequestMode() {
         return call("libgtk-4.so.1", "gtk_widget_get_request_mode", [
             {
@@ -892,6 +1914,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the `GtkRoot` widget of the widget.
+     *
+     * This function will return `NULL` if the widget is not contained
+     * inside a widget tree with a root widget.
+     *
+     * `GtkRoot` widgets will return themselves here.
+     */
     getRoot() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_root", [
             {
@@ -903,6 +1933,21 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Root);
     }
+    /**
+     * Retrieves the internal scale factor that maps from window
+     * coordinates to the actual device pixels.
+     *
+     * On traditional systems this is 1, on high density outputs,
+     * it can be a higher value (typically 2).
+     *
+     * See [method@Gdk.Surface.get_scale_factor].
+     *
+     * Note that modern systems may support *fractional* scaling,
+     * where the scale factor is not an integer. On such systems,
+     * this function will return the next higher integer value,
+     * but you probably want to use [method@Gdk.Surface.get_scale]
+     * to get the fractional scale value.
+     */
     getScaleFactor() {
         return call("libgtk-4.so.1", "gtk_widget_get_scale_factor", [
             {
@@ -911,6 +1956,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the widget’s sensitivity.
+     *
+     * This function returns the value that has been set using
+     * [method@Gtk.Widget.set_sensitive]).
+     *
+     * The effective sensitivity of a widget is however determined
+     * by both its own and its parent widget’s sensitivity.
+     * See [method@Gtk.Widget.is_sensitive].
+     */
     getSensitive() {
         return call("libgtk-4.so.1", "gtk_widget_get_sensitive", [
             {
@@ -919,6 +1974,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the settings object holding the settings used for the widget.
+     *
+     * Note that this function can only be called when the `GtkWidget`
+     * is attached to a toplevel, since the settings object is specific
+     * to a particular display. If you want to monitor the widget for
+     * changes in its settings, connect to the `notify::display` signal.
+     */
     getSettings() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_settings", [
             {
@@ -928,6 +1991,21 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Settings);
     }
+    /**
+     * Returns the content width or height of the widget.
+     *
+     * Which dimension is returned depends on @orientation.
+     *
+     * This is equivalent to calling [method@Gtk.Widget.get_width]
+     * for [enum@Gtk.Orientation.horizontal] or [method@Gtk.Widget.get_height]
+     * for [enum@Gtk.Orientation.vertical], but can be used when
+     * writing orientation-independent code, such as when
+     * implementing [iface@Gtk.Orientable] widgets.
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     * @param orientation - the orientation to query
+     */
     getSize(orientation) {
         return call("libgtk-4.so.1", "gtk_widget_get_size", [
             {
@@ -940,6 +2018,20 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the size request that was explicitly set for the widget.
+     *
+     * A value of -1 stored in `width` or `height` indicates that that
+     * dimension has not been set explicitly and the natural requisition
+     * of the widget will be used instead.
+     *
+     * See [method@Gtk.Widget.set_size_request].
+     *
+     * To get the size a widget will actually request, call
+     * [method@Gtk.Widget.measure] instead of this function.
+     * @param width - return location for width
+     * @param height - return location for height
+     */
     getSizeRequest(width, height) {
         call("libgtk-4.so.1", "gtk_widget_get_size_request", [
             {
@@ -964,6 +2056,17 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns the widget state as a flag set.
+     *
+     * It is worth mentioning that the effective [flags@Gtk.StateFlags.insensitive]
+     * state will be returned, that is, also based on parent insensitivity,
+     * even if `widget` itself is sensitive.
+     *
+     * Also note that if you are looking for a way to obtain the
+     * [flags@Gtk.StateFlags] to pass to a [class@Gtk.StyleContext]
+     * method, you should look at [method@Gtk.StyleContext.get_state].
+     */
     getStateFlags() {
         return call("libgtk-4.so.1", "gtk_widget_get_state_flags", [
             {
@@ -972,6 +2075,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the style context associated to the widget.
+     *
+     * The returned object is guaranteed to be the same
+     * for the lifetime of @widget.
+     */
     getStyleContext() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_style_context", [
             {
@@ -981,6 +2090,20 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, StyleContext);
     }
+    /**
+     * Fetches an object build from the template XML for `widget_type` in
+     * the widget.
+     *
+     * This will only report children which were previously declared
+     * with [method@Gtk.WidgetClass.bind_template_child_full] or one of its
+     * variants.
+     *
+     * This function is only meant to be called for code which is private
+     * to the `widget_type` which declared the child and is meant for language
+     * bindings which cannot easily make use of the GObject structure offsets.
+     * @param widgetType - The `GType` to get a template child for
+     * @param name - ID of the child defined in the template XML
+     */
     getTemplateChild(widgetType, name) {
         const ptr = call("libgtk-4.so.1", "gtk_widget_get_template_child", [
             {
@@ -998,6 +2121,13 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, GObject.GObject);
     }
+    /**
+     * Gets the contents of the tooltip for the widget.
+     *
+     * If the tooltip has not been set using
+     * [method@Gtk.Widget.set_tooltip_markup], this
+     * function returns `NULL`.
+     */
     getTooltipMarkup() {
         return call("libgtk-4.so.1", "gtk_widget_get_tooltip_markup", [
             {
@@ -1006,6 +2136,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the contents of the tooltip for the widget.
+     *
+     * If the @widget's tooltip was set using
+     * [method@Gtk.Widget.set_tooltip_markup],
+     * this function will return the escaped text.
+     */
     getTooltipText() {
         return call("libgtk-4.so.1", "gtk_widget_get_tooltip_text", [
             {
@@ -1014,6 +2151,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the vertical alignment of the widget.
+     */
     getValign() {
         return call("libgtk-4.so.1", "gtk_widget_get_valign", [
             {
@@ -1022,6 +2162,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets whether the widget would like any available extra vertical
+     * space.
+     *
+     * See [method@Gtk.Widget.get_hexpand] for more detail.
+     */
     getVexpand() {
         return call("libgtk-4.so.1", "gtk_widget_get_vexpand", [
             {
@@ -1030,6 +2176,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether the `vexpand` flag has been explicitly set.
+     *
+     * See [method@Gtk.Widget.get_hexpand_set] for more detail.
+     */
     getVexpandSet() {
         return call("libgtk-4.so.1", "gtk_widget_get_vexpand_set", [
             {
@@ -1038,6 +2189,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether the widget is visible.
+     *
+     * If you want to take into account whether the widget’s
+     * parent is also marked as visible, use
+     * [method@Gtk.Widget.is_visible] instead.
+     *
+     * This function does not check if the widget is
+     * obscured in any way.
+     *
+     * See [method@Gtk.Widget.set_visible].
+     */
     getVisible() {
         return call("libgtk-4.so.1", "gtk_widget_get_visible", [
             {
@@ -1046,6 +2209,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the content width of the widget.
+     *
+     * This function returns the width passed to its
+     * size-allocate implementation, which is the width you
+     * should be using in [vfunc@Gtk.Widget.snapshot].
+     *
+     * For pointer events, see [method@Gtk.Widget.contains].
+     *
+     * To learn more about widget sizes, see the coordinate
+     * system overview.
+     */
     getWidth() {
         return call("libgtk-4.so.1", "gtk_widget_get_width", [
             {
@@ -1054,6 +2229,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Causes `widget` to have the keyboard focus for the window
+     * that it belongs to.
+     *
+     * If `widget` is not focusable, or its [vfunc@Gtk.Widget.grab_focus]
+     * implementation cannot transfer the focus to a descendant of `widget` that is focusable, it will not take focus and false will be returned.
+     *
+     * Calling [method@Gtk.Widget.grab_focus] on an already focused widget
+     * is allowed, should not have an effect, and return true.
+     */
     grabFocus() {
         return call("libgtk-4.so.1", "gtk_widget_grab_focus", [
             {
@@ -1062,6 +2247,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether a style class is currently applied to the widget.
+     * @param cssClass - style class, without the leading period
+     */
     hasCssClass(cssClass) {
         return call("libgtk-4.so.1", "gtk_widget_has_css_class", [
             {
@@ -1074,6 +2263,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether the widget is the current default widget
+     * within its toplevel.
+     */
     hasDefault() {
         return call("libgtk-4.so.1", "gtk_widget_has_default", [
             {
@@ -1082,6 +2275,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines if the widget has the global input focus.
+     *
+     * See [method@Gtk.Widget.is_focus] for the difference between
+     * having the global input focus, and only having the focus
+     * within a toplevel.
+     */
     hasFocus() {
         return call("libgtk-4.so.1", "gtk_widget_has_focus", [
             {
@@ -1090,6 +2290,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines if the widget should show a visible indication that
+     * it has the global input focus.
+     *
+     * This is a convenience function that takes into account whether
+     * focus indication should currently be shown in the toplevel window
+     * of @widget. See [method@Gtk.Window.get_focus_visible] for more
+     * information about focus indication.
+     *
+     * To find out if the widget has the global input focus, use
+     * [method@Gtk.Widget.has_focus].
+     */
     hasVisibleFocus() {
         return call("libgtk-4.so.1", "gtk_widget_has_visible_focus", [
             {
@@ -1098,6 +2310,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Reverses the effects of [method.Gtk.Widget.show].
+     *
+     * This is causing the widget to be hidden (invisible to the user).
+     */
     hide() {
         call("libgtk-4.so.1", "gtk_widget_hide", [
             {
@@ -1106,6 +2323,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether the widget is currently being destroyed.
+     *
+     * This information can sometimes be used to avoid doing
+     * unnecessary work.
+     */
     inDestruction() {
         return call("libgtk-4.so.1", "gtk_widget_in_destruction", [
             {
@@ -1114,6 +2337,28 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Creates and initializes child widgets defined in templates.
+     *
+     * This function must be called in the instance initializer
+     * for any class which assigned itself a template using
+     * [method@Gtk.WidgetClass.set_template].
+     *
+     * It is important to call this function in the instance initializer
+     * of a widget subclass and not in `GObject.constructed()` or
+     * `GObject.constructor()` for two reasons:
+     *
+     * - derived widgets will assume that the composite widgets
+     * defined by its parent classes have been created in their
+     * relative instance initializers
+     * - when calling `g_object_new()` on a widget with composite templates,
+     * it’s important to build the composite widgets before the construct
+     * properties are set. Properties passed to `g_object_new()` should
+     * take precedence over properties set in the private template XML
+     *
+     * A good rule of thumb is to call this function as the first thing in
+     * an instance initialization function.
+     */
     initTemplate() {
         call("libgtk-4.so.1", "gtk_widget_init_template", [
             {
@@ -1122,6 +2367,23 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Inserts an action group into the widget's actions.
+     *
+     * Children of `widget` that implement [iface@Gtk.Actionable] can
+     * then be associated with actions in `group` by setting their
+     * “action-name” to @prefix.`action-name`.
+     *
+     * Note that inheritance is defined for individual actions. I.e.
+     * even if you insert a group with prefix @prefix, actions with
+     * the same prefix will still be inherited from the parent, unless
+     * the group contains an action with the same name.
+     *
+     * If `group` is `NULL`, a previously inserted group for `name` is
+     * removed from @widget.
+     * @param name - the prefix for actions in @group
+     * @param group - an action group
+     */
     insertActionGroup(name, group) {
         call("libgtk-4.so.1", "gtk_widget_insert_action_group", [
             {
@@ -1139,6 +2401,28 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the parent widget of the widget.
+     *
+     * In contrast to [method@Gtk.Widget.set_parent], this function
+     * inserts `widget` at a specific position into the list of children
+     * of the `parent` widget.
+     *
+     * It will be placed after @previous_sibling, or at the beginning if
+     * `previous_sibling` is `NULL`.
+     *
+     * After calling this function, `gtk_widget_get_prev_sibling (widget)`
+     * will return @previous_sibling.
+     *
+     * If `parent` is already set as the parent widget of @widget, this
+     * function can also be used to reorder `widget` in the child widget
+     * list of @parent.
+     *
+     * This function is primarily meant for widget implementations; if you are
+     * just using a widget, you *must* use its own API for adding children.
+     * @param parent - the parent widget to insert `widget` into
+     * @param previousSibling - the new previous sibling of @widget
+     */
     insertAfter(parent, previousSibling) {
         call("libgtk-4.so.1", "gtk_widget_insert_after", [
             {
@@ -1156,6 +2440,27 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the parent widget of the widget.
+     *
+     * In contrast to [method@Gtk.Widget.set_parent], this function
+     * inserts `widget` at a specific position into the list of children
+     * of the `parent` widget.
+     *
+     * It will be placed before @next_sibling, or at the end if
+     * `next_sibling` is `NULL`.
+     *
+     * After calling this function, `gtk_widget_get_next_sibling (widget)`
+     * will return @next_sibling.
+     *
+     * If `parent` is already set as the parent widget of @widget, this function
+     * can also be used to reorder `widget` in the child widget list of @parent.
+     *
+     * This function is primarily meant for widget implementations; if you are
+     * just using a widget, you *must* use its own API for adding children.
+     * @param parent - the parent widget to insert `widget` into
+     * @param nextSibling - the new next sibling of @widget
+     */
     insertBefore(parent, nextSibling) {
         call("libgtk-4.so.1", "gtk_widget_insert_before", [
             {
@@ -1173,6 +2478,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Determines whether the widget is a descendent of @ancestor.
+     * @param ancestor - another `GtkWidget`
+     */
     isAncestor(ancestor) {
         return call("libgtk-4.so.1", "gtk_widget_is_ancestor", [
             {
@@ -1185,6 +2494,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether the widget can be drawn to.
+     *
+     * A widget can be drawn if it is mapped and visible.
+     */
     isDrawable() {
         return call("libgtk-4.so.1", "gtk_widget_is_drawable", [
             {
@@ -1193,6 +2507,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines if the widget is the focus widget within its
+     * toplevel.
+     *
+     * This does not mean that the [property@Gtk.Widget:has-focus]
+     * property is necessarily set; [property@Gtk.Widget:has-focus]
+     * will only be set if the toplevel widget additionally has the
+     * global input focus.
+     */
     isFocus() {
         return call("libgtk-4.so.1", "gtk_widget_is_focus", [
             {
@@ -1201,6 +2524,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the widget’s effective sensitivity.
+     *
+     * This means it is sensitive itself and also its
+     * parent widget is sensitive.
+     */
     isSensitive() {
         return call("libgtk-4.so.1", "gtk_widget_is_sensitive", [
             {
@@ -1209,6 +2538,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Determines whether the widget and all its parents are marked as
+     * visible.
+     *
+     * This function does not check if the widget is obscured in any way.
+     *
+     * See also [method@Gtk.Widget.get_visible] and
+     * [method@Gtk.Widget.set_visible].
+     */
     isVisible() {
         return call("libgtk-4.so.1", "gtk_widget_is_visible", [
             {
@@ -1217,6 +2555,37 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Emits the [signal@Gtk.Widget::keynav-failed] signal on the widget.
+     *
+     * This function should be called whenever keyboard navigation
+     * within a single widget hits a boundary.
+     *
+     * The return value of this function should be interpreted
+     * in a way similar to the return value of
+     * [method@Gtk.Widget.child_focus]. When true is returned,
+     * stay in the widget, the failed keyboard navigation is ok
+     * and/or there is nowhere we can/should move the focus to.
+     * When false is returned, the caller should continue with
+     * keyboard navigation outside the widget, e.g. by calling
+     * [method@Gtk.Widget.child_focus] on the widget’s toplevel.
+     *
+     * The default [signal@Gtk.Widget::keynav-failed] handler returns
+     * false for [enum@Gtk.DirectionType.tab-forward] and
+     * [enum@Gtk.DirectionType.tab-backward]. For the other values
+     * of [enum@Gtk.DirectionType] it returns true.
+     *
+     * Whenever the default handler returns true, it also calls
+     * [method@Gtk.Widget.error_bell] to notify the user of the
+     * failed keyboard navigation.
+     *
+     * A use case for providing an own implementation of `::keynav-failed`
+     * (either by connecting to it or by overriding it) would be a row of
+     * [class@Gtk.Entry] widgets where the user should be able to navigate
+     * the entire row with the cursor keys, as e.g. known from user
+     * interfaces that require entering license keys.
+     * @param direction - direction of focus movement
+     */
     keynavFailed(direction) {
         return call("libgtk-4.so.1", "gtk_widget_keynav_failed", [
             {
@@ -1229,6 +2598,19 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the widgets for which this widget is the target of a
+     * mnemonic.
+     *
+     * Typically, these widgets will be labels. See, for example,
+     * [method@Gtk.Label.set_mnemonic_widget].
+     *
+     * The widgets in the list are not individually referenced.
+     * If you want to iterate through the list and perform actions
+     * involving callbacks that might destroy the widgets, you
+     * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+     * first, and then unref all the widgets afterwards.
+     */
     listMnemonicLabels() {
         const ptrs = call("libgtk-4.so.1", "gtk_widget_list_mnemonic_labels", [
             {
@@ -1243,6 +2625,11 @@ export class Widget extends GObject.InitiallyUnowned {
         });
         return ptrs.map((ptr) => getObject(ptr, Widget));
     }
+    /**
+     * Causes a widget to be mapped if it isn’t already.
+     *
+     * This function is only for use in widget implementations.
+     */
     map() {
         call("libgtk-4.so.1", "gtk_widget_map", [
             {
@@ -1251,6 +2638,20 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Measures `widget` in the orientation `orientation` and for the given @for_size.
+     *
+     * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size` is 300, this functions will compute the minimum and natural width of `widget` if it is allocated at a height of 300 pixels.
+     *
+     * See GtkWidget’s geometry management section for
+     * a more details on implementing `GtkWidgetClass.measure()`.
+     * @param orientation - the orientation to measure
+     * @param forSize - Size for the opposite of @orientation, i.e.
+     * @param minimum - location to store the minimum size
+     * @param natural - location to store the natural size
+     * @param minimumBaseline - location to store the baseline
+     * @param naturalBaseline - location to store the baseline
+     */
     measure(orientation, forSize, minimum, natural, minimumBaseline, naturalBaseline) {
         call("libgtk-4.so.1", "gtk_widget_measure", [
             {
@@ -1299,6 +2700,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Emits the [signal@Gtk.Widget::mnemonic-activate] signal.
+     * @param groupCycling - true if there are other widgets with the same mnemonic
+     */
     mnemonicActivate(groupCycling) {
         return call("libgtk-4.so.1", "gtk_widget_mnemonic_activate", [
             {
@@ -1311,6 +2716,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns a list model to track the children of the widget.
+     *
+     * Calling this function will enable extra internal bookkeeping
+     * to track children and emit signals on the returned listmodel.
+     * It may slow down operations a lot.
+     *
+     * Applications should try hard to avoid calling this function
+     * because of the slowdowns.
+     */
     observeChildren() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_observe_children", [
             {
@@ -1320,6 +2735,16 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gio.ListModel);
     }
+    /**
+     * Returns a list model to track the event controllers of the widget.
+     *
+     * Calling this function will enable extra internal bookkeeping
+     * to track controllers and emit signals on the returned listmodel.
+     * It may slow down operations a lot.
+     *
+     * Applications should try hard to avoid calling this function
+     * because of the slowdowns.
+     */
     observeControllers() {
         const ptr = call("libgtk-4.so.1", "gtk_widget_observe_controllers", [
             {
@@ -1329,6 +2754,25 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, Gio.ListModel);
     }
+    /**
+     * Finds the descendant of the widget closest to a point.
+     *
+     * The point (x, y) must be given in widget coordinates, so (0, 0)
+     * is assumed to be the top left of @widget's content area.
+     *
+     * Usually widgets will return `NULL` if the given coordinate is not
+     * contained in `widget` checked via [method@Gtk.Widget.contains].
+     * Otherwise they will recursively try to find a child that does
+     * not return `NULL`. Widgets are however free to customize their
+     * picking algorithm.
+     *
+     * This function is used on the toplevel to determine the widget
+     * below the mouse cursor for purposes of hover highlighting and
+     * delivering events.
+     * @param x - x coordinate to test, relative to @widget's origin
+     * @param y - y coordinate to test, relative to @widget's origin
+     * @param flags - flags to influence what is picked
+     */
     pick(x, y, flags) {
         const ptr = call("libgtk-4.so.1", "gtk_widget_pick", [
             {
@@ -1352,6 +2796,18 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Flags the widget for a rerun of the [vfunc@Gtk.Widget.size_allocate]
+     * function.
+     *
+     * Use this function instead of [method@Gtk.Widget.queue_resize]
+     * when the @widget's size request didn't change but it wants to
+     * reposition its contents.
+     *
+     * An example user of this function is [method@Gtk.Widget.set_halign].
+     *
+     * This function is only for use in widget implementations.
+     */
     queueAllocate() {
         call("libgtk-4.so.1", "gtk_widget_queue_allocate", [
             {
@@ -1360,6 +2816,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Schedules this widget to be redrawn.
+     *
+     * The redraw will happen in the paint phase
+     * of the current or the next frame.
+     *
+     * This means @widget's [vfunc@Gtk.Widget.snapshot]
+     * implementation will be called.
+     */
     queueDraw() {
         call("libgtk-4.so.1", "gtk_widget_queue_draw", [
             {
@@ -1368,6 +2833,21 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Flags a widget to have its size renegotiated.
+     *
+     * This should be called when a widget for some reason has a new
+     * size request. For example, when you change the text in a
+     * [class@Gtk.Label], the label queues a resize to ensure there’s
+     * enough space for the new text.
+     *
+     * Note that you cannot call gtk_widget_queue_resize() on a widget
+     * from inside its implementation of the [vfunc@Gtk.Widget.size_allocate]
+     * virtual method. Calls to gtk_widget_queue_resize() from inside
+     * [vfunc@Gtk.Widget.size_allocate] will be silently ignored.
+     *
+     * This function is only for use in widget implementations.
+     */
     queueResize() {
         call("libgtk-4.so.1", "gtk_widget_queue_resize", [
             {
@@ -1376,6 +2856,24 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates the GDK resources associated with a widget.
+     *
+     * Normally realization happens implicitly; if you show a widget
+     * and all its parent containers, then the widget will be realized
+     * and mapped automatically.
+     *
+     * Realizing a widget requires all the widget’s parent widgets to be
+     * realized; calling this function realizes the widget’s parents
+     * in addition to `widget` itself. If a widget is not yet inside a
+     * toplevel window when you realize it, bad things will happen.
+     *
+     * This function is primarily used in widget implementations, and
+     * isn’t very useful otherwise. Many times when you think you might
+     * need it, a better approach is to connect to a signal that will be
+     * called after the widget is realized automatically, such as
+     * [signal@Gtk.Widget::realize].
+     */
     realize() {
         call("libgtk-4.so.1", "gtk_widget_realize", [
             {
@@ -1384,6 +2882,16 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes an event controller from the widget.
+     *
+     * The removed event controller will not receive any more events,
+     * and should not be used again.
+     *
+     * Widgets will remove all event controllers automatically when they
+     * are destroyed, there is normally no need to call this function.
+     * @param controller - an event controller
+     */
     removeController(controller) {
         call("libgtk-4.so.1", "gtk_widget_remove_controller", [
             {
@@ -1396,6 +2904,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes a style from the widget.
+     *
+     * After this, the style of `widget` will stop matching for @css_class.
+     * @param cssClass - style class to remove from @widget, without the leading period
+     */
     removeCssClass(cssClass) {
         call("libgtk-4.so.1", "gtk_widget_remove_css_class", [
             {
@@ -1408,6 +2922,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes a widget from the list of mnemonic labels for this widget.
+     *
+     * See [method@Gtk.Widget.list_mnemonic_labels].
+     *
+     * The widget must have previously been added to the list with
+     * [method@Gtk.Widget.add_mnemonic_label].
+     * @param label - a widget that is a mnemonic label for @widget
+     */
     removeMnemonicLabel(label) {
         call("libgtk-4.so.1", "gtk_widget_remove_mnemonic_label", [
             {
@@ -1420,6 +2943,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes a tick callback previously registered with
+     * [method@Gtk.Widget.add_tick_callback].
+     * @param id - an ID returned by [method@Gtk.Widget.add_tick_callback]
+     */
     removeTickCallback(id) {
         call("libgtk-4.so.1", "gtk_widget_remove_tick_callback", [
             {
@@ -1432,6 +2960,23 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the input focus can enter the widget or
+     * any of its children.
+     *
+     * Applications should set `can_focus` to false to mark a
+     * widget as for pointer/touch use only.
+     *
+     * Note that having `can_focus` be true is only one of the
+     * necessary conditions for being focusable. A widget must
+     * also be sensitive and focusable and not have an ancestor
+     * that is marked as not can-focus in order to receive input
+     * focus.
+     *
+     * See [method@Gtk.Widget.grab_focus] for actually setting
+     * the input focus on a widget.
+     * @param canFocus - whether the input focus can enter
+     */
     setCanFocus(canFocus) {
         call("libgtk-4.so.1", "gtk_widget_set_can_focus", [
             {
@@ -1444,6 +2989,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the widget can be the target of pointer events.
+     * @param canTarget - whether this widget should be able to
+     */
     setCanTarget(canTarget) {
         call("libgtk-4.so.1", "gtk_widget_set_can_target", [
             {
@@ -1456,6 +3005,25 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the widget should be mapped along with its parent.
+     *
+     * The child visibility can be set for widget before it is added
+     * to a container with [method@Gtk.Widget.set_parent], to avoid
+     * mapping children unnecessary before immediately unmapping them.
+     * However it will be reset to its default state of true when the
+     * widget is removed from a container.
+     *
+     * Note that changing the child visibility of a widget does not
+     * queue a resize on the widget. Most of the time, the size of
+     * a widget is computed from all visible children, whether or
+     * not they are mapped. If this is not the case, the container
+     * can queue a resize itself.
+     *
+     * This function is only useful for widget implementations
+     * and should never be called by an application.
+     * @param childVisible - whether `widget` should be mapped along
+     */
     setChildVisible(childVisible) {
         call("libgtk-4.so.1", "gtk_widget_set_child_visible", [
             {
@@ -1468,6 +3036,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Replaces the current style classes of the widget with @classes.
+     * @param classes - `NULL`-terminated list of style classes
+     */
     setCssClasses(classes) {
         call("libgtk-4.so.1", "gtk_widget_set_css_classes", [
             {
@@ -1480,6 +3052,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the cursor to be shown when the pointer hovers over
+     * the widget.
+     *
+     * If the `cursor` is `NULL`, `widget` will use the cursor
+     * inherited from its parent.
+     * @param cursor - the new cursor
+     */
     setCursor(cursor) {
         call("libgtk-4.so.1", "gtk_widget_set_cursor", [
             {
@@ -1493,6 +3073,19 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the cursor to be shown when the pointer hovers over
+     * the widget.
+     *
+     * This is a utility function that creates a cursor via
+     * [ctor@Gdk.Cursor.new_from_name] and then sets it on `widget` with [method@Gtk.Widget.set_cursor]. See those functions for
+     * details.
+     *
+     * On top of that, this function allows `name` to be `NULL`, which
+     * will do the same as calling [method@Gtk.Widget.set_cursor]
+     * with a `NULL` cursor.
+     * @param name - the name of the cursor
+     */
     setCursorFromName(name) {
         call("libgtk-4.so.1", "gtk_widget_set_cursor_from_name", [
             {
@@ -1506,6 +3099,24 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the reading direction on the widget.
+     *
+     * This direction controls the primary direction for widgets
+     * containing text, and also the direction in which the children
+     * of a container are packed. The ability to set the direction is
+     * present in order so that correct localization into languages with
+     * right-to-left reading directions can be done.
+     *
+     * Generally, applications will let the default reading direction
+     * prevail, except for widgets where the children are arranged in
+     * an order that is explicitly visual rather than logical (such as
+     * buttons for text justification).
+     *
+     * If the direction is set to [enum@Gtk.TextDirection.none], then
+     * the value set by [func@Gtk.Widget.set_default_direction] will be used.
+     * @param dir - the new direction
+     */
     setDirection(dir) {
         call("libgtk-4.so.1", "gtk_widget_set_direction", [
             {
@@ -1518,6 +3129,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the focus child of the widget.
+     *
+     * This function is only suitable for widget implementations.
+     * If you want a certain widget to get the input focus, call
+     * [method@Gtk.Widget.grab_focus] on it.
+     * @param child - a direct child widget of `widget`   or `NULL` to unset the focus child
+     */
     setFocusChild(child) {
         call("libgtk-4.so.1", "gtk_widget_set_focus_child", [
             {
@@ -1531,6 +3150,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the widget should grab focus when it is clicked
+     * with the mouse.
+     *
+     * Making mouse clicks not grab focus is useful in places like
+     * toolbars where you don’t want the keyboard focus removed from
+     * the main area of the application.
+     * @param focusOnClick - whether the widget should grab focus when clicked
+     */
     setFocusOnClick(focusOnClick) {
         call("libgtk-4.so.1", "gtk_widget_set_focus_on_click", [
             {
@@ -1543,6 +3171,22 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the widget can own the input focus.
+     *
+     * Widget implementations should set `focusable` to true in
+     * their init() function if they want to receive keyboard input.
+     *
+     * Note that having `focusable` be true is only one of the
+     * necessary conditions for being focusable. A widget must
+     * also be sensitive and can-focus and not have an ancestor
+     * that is marked as not can-focus in order to receive input
+     * focus.
+     *
+     * See [method@Gtk.Widget.grab_focus] for actually setting
+     * the input focus on a widget.
+     * @param focusable - whether or not `widget` can own the input focus
+     */
     setFocusable(focusable) {
         call("libgtk-4.so.1", "gtk_widget_set_focusable", [
             {
@@ -1555,6 +3199,17 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the font map to use for text rendering in the widget.
+     *
+     * The font map is the object that is used to look up fonts.
+     * Setting a custom font map can be useful in special situations,
+     * e.g. when you need to add application-specific fonts to the set
+     * of available fonts.
+     *
+     * When not set, the widget will inherit the font map from its parent.
+     * @param fontMap - a `PangoFontMap`
+     */
     setFontMap(fontMap) {
         call("libgtk-4.so.1", "gtk_widget_set_font_map", [
             {
@@ -1568,6 +3223,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `cairo_font_options_t` used for text rendering
+     * in the widget.
+     *
+     * When not set, the default font options for the `GdkDisplay`
+     * will be used.
+     * @param options - a `cairo_font_options_t` struct
+     */
     setFontOptions(options) {
         call("libgtk-4.so.1", "gtk_widget_set_font_options", [
             {
@@ -1586,6 +3249,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the horizontal alignment of the widget.
+     * @param align - the horizontal alignment
+     */
     setHalign(align) {
         call("libgtk-4.so.1", "gtk_widget_set_halign", [
             {
@@ -1598,6 +3265,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the `has-tooltip` property on the widget.
+     * @param hasTooltip - whether or not `widget` has a tooltip
+     */
     setHasTooltip(hasTooltip) {
         call("libgtk-4.so.1", "gtk_widget_set_has_tooltip", [
             {
@@ -1610,6 +3281,35 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the widget would like any available extra horizontal
+     * space.
+     *
+     * When a user resizes a window, widgets with expand set to true generally
+     * receive the extra space. For example, a list or scrollable area
+     * or document in your window would often be set to expand.
+     *
+     * Call this function to set the expand flag if you would like your
+     * widget to become larger horizontally when the window has extra
+     * room.
+     *
+     * By default, widgets automatically expand if any of their children
+     * want to expand. (To see if a widget will automatically expand given
+     * its current children and state, call [method@Gtk.Widget.compute_expand].
+     * A widget can decide how the expandability of children affects its
+     * own expansion by overriding the `compute_expand` virtual method on
+     * `GtkWidget`.).
+     *
+     * Setting hexpand explicitly with this function will override the
+     * automatic expand behavior.
+     *
+     * This function forces the widget to expand or not to expand,
+     * regardless of children. The override occurs because
+     * [method@Gtk.Widget.set_hexpand] sets the hexpand-set property (see
+     * [method@Gtk.Widget.set_hexpand_set]) which causes the widget’s hexpand
+     * value to be used, rather than looking at children and widget state.
+     * @param expand - whether to expand
+     */
     setHexpand(expand) {
         call("libgtk-4.so.1", "gtk_widget_set_hexpand", [
             {
@@ -1622,6 +3322,23 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the hexpand flag will be used.
+     *
+     * The [property@Gtk.Widget:hexpand-set] property will be set
+     * automatically when you call [method@Gtk.Widget.set_hexpand]
+     * to set hexpand, so the most likely reason to use this function
+     * would be to unset an explicit expand flag.
+     *
+     * If hexpand is set, then it overrides any computed
+     * expand value based on child widgets. If hexpand is not
+     * set, then the expand value depends on whether any
+     * children of the widget would like to expand.
+     *
+     * There are few reasons to use this function, but it’s here
+     * for completeness and consistency.
+     * @param set - value for hexpand-set property
+     */
     setHexpandSet(set) {
         call("libgtk-4.so.1", "gtk_widget_set_hexpand_set", [
             {
@@ -1634,6 +3351,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the layout manager to use for measuring and allocating children
+     * of the widget.
+     * @param layoutManager - a layout manager
+     */
     setLayoutManager(layoutManager) {
         call("libgtk-4.so.1", "gtk_widget_set_layout_manager", [
             {
@@ -1647,6 +3369,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the widget acts like a modal dialog,
+     * with respect to event delivery.
+     * @param limitEvents - whether to limit events
+     */
     setLimitEvents(limitEvents) {
         call("libgtk-4.so.1", "gtk_widget_set_limit_events", [
             {
@@ -1659,6 +3386,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the bottom margin of the widget.
+     * @param margin - the bottom margin
+     */
     setMarginBottom(margin) {
         call("libgtk-4.so.1", "gtk_widget_set_margin_bottom", [
             {
@@ -1671,6 +3402,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the end margin of the widget.
+     * @param margin - the end margin
+     */
     setMarginEnd(margin) {
         call("libgtk-4.so.1", "gtk_widget_set_margin_end", [
             {
@@ -1683,6 +3418,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the start margin of the widget.
+     * @param margin - the start margin
+     */
     setMarginStart(margin) {
         call("libgtk-4.so.1", "gtk_widget_set_margin_start", [
             {
@@ -1695,6 +3434,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the top margin of the widget.
+     * @param margin - the top margin
+     */
     setMarginTop(margin) {
         call("libgtk-4.so.1", "gtk_widget_set_margin_top", [
             {
@@ -1707,6 +3450,20 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a widgets name.
+     *
+     * Setting a name allows you to refer to the widget from a
+     * CSS file. You can apply a style to widgets with a particular name
+     * in the CSS file. See the documentation for the CSS syntax (on the
+     * same page as the docs for [class@Gtk.StyleContext].
+     *
+     * Note that the CSS syntax has certain special characters to delimit
+     * and represent elements in a selector (period, #, >, *...), so using
+     * these will make your widget impossible to match by name. Any combination
+     * of alphanumeric symbols, dashes and underscores will suffice.
+     * @param name - name for the widget
+     */
     setName(name) {
         call("libgtk-4.so.1", "gtk_widget_set_name", [
             {
@@ -1719,6 +3476,32 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Requests the widget to be rendered partially transparent.
+     *
+     * An opacity of 0 is fully transparent and an opacity of 1
+     * is fully opaque.
+     *
+     * Opacity works on both toplevel widgets and child widgets, although
+     * there are some limitations: For toplevel widgets, applying opacity
+     * depends on the capabilities of the windowing system. On X11, this
+     * has any effect only on X displays with a compositing manager, see
+     * [method@Gdk.Display.is_composited]. On Windows and Wayland it will
+     * always work, although setting a window’s opacity after the window
+     * has been shown may cause some flicker.
+     *
+     * Note that the opacity is inherited through inclusion — if you set
+     * a toplevel to be partially translucent, all of its content will
+     * appear translucent, since it is ultimatively rendered on that
+     * toplevel. The opacity value itself is not inherited by child
+     * widgets (since that would make widgets deeper in the hierarchy
+     * progressively more translucent). As a consequence, [class@Gtk.Popover]
+     * instances and other [iface@Gtk.Native] widgets with their own surface
+     * will use their own opacity value, and thus by default appear
+     * non-translucent, even if they are attached to a toplevel that
+     * is translucent.
+     * @param opacity - desired opacity, between 0 and 1
+     */
     setOpacity(opacity) {
         call("libgtk-4.so.1", "gtk_widget_set_opacity", [
             {
@@ -1731,6 +3514,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets how the widget treats content that is drawn outside the
+     * it's content area.
+     *
+     * See the definition of [enum@Gtk.Overflow] for details.
+     *
+     * This setting is provided for widget implementations and
+     * should not be used by application code.
+     *
+     * The default value is [enum@Gtk.Overflow.visible].
+     * @param overflow - desired overflow value
+     */
     setOverflow(overflow) {
         call("libgtk-4.so.1", "gtk_widget_set_overflow", [
             {
@@ -1743,6 +3538,17 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the parent widget of the widget.
+     *
+     * This takes care of details such as updating the state and style
+     * of the child to reflect its new location and resizing the parent.
+     * The opposite function is [method@Gtk.Widget.unparent].
+     *
+     * This function is useful only when implementing subclasses of
+     * `GtkWidget`.
+     * @param parent - parent widget
+     */
     setParent(parent) {
         call("libgtk-4.so.1", "gtk_widget_set_parent", [
             {
@@ -1755,6 +3561,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the widget will be treated as the default
+     * widget within its toplevel when it has the focus, even if
+     * another widget is the default.
+     * @param receivesDefault - whether or not `widget` can be a default widget
+     */
     setReceivesDefault(receivesDefault) {
         call("libgtk-4.so.1", "gtk_widget_set_receives_default", [
             {
@@ -1767,6 +3579,15 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the sensitivity of the widget.
+     *
+     * A widget is sensitive if the user can interact with it.
+     * Insensitive widgets are “grayed out” and the user can’t
+     * interact with them. Insensitive widgets are known as
+     * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+     * @param sensitive - true to make the widget sensitive
+     */
     setSensitive(sensitive) {
         call("libgtk-4.so.1", "gtk_widget_set_sensitive", [
             {
@@ -1779,6 +3600,43 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the minimum size of the widget.
+     *
+     * That is, the widget’s size request will be at least `width` by @height. You can use this function to force a widget to
+     * be larger than it normally would be.
+     *
+     * In most cases, [method@Gtk.Window.set_default_size] is a better
+     * choice for toplevel windows than this function; setting the default
+     * size will still allow users to shrink the window. Setting the size
+     * request will force them to leave the window at least as large as
+     * the size request.
+     *
+     * Note the inherent danger of setting any fixed size - themes,
+     * translations into other languages, different fonts, and user action
+     * can all change the appropriate size for a given widget. So, it is
+     * basically impossible to hardcode a size that will always work.
+     *
+     * The size request of a widget is the smallest size a widget can
+     * accept while still functioning well and drawing itself correctly.
+     * However in some strange cases a widget may be allocated less than
+     * its requested size, and in many cases a widget may be allocated more
+     * space than it requested.
+     *
+     * If the size request in a given direction is -1 (unset), then
+     * the “natural” size request of the widget will be used instead.
+     *
+     * The size request set here does not include any margin from the
+     * properties
+     * [property@Gtk.Widget:margin-start],
+     * [property@Gtk.Widget:margin-end],
+     * [property@Gtk.Widget:margin-top], and
+     * [property@Gtk.Widget:margin-bottom], but it does include pretty
+     * much all other padding or border properties set by any subclass
+     * of `GtkWidget`.
+     * @param width - width `widget` should request, or -1 to unset
+     * @param height - height `widget` should request, or -1 to unset
+     */
     setSizeRequest(width, height) {
         call("libgtk-4.so.1", "gtk_widget_set_size_request", [
             {
@@ -1795,6 +3653,19 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Turns on flag values in the current widget state.
+     *
+     * Typical widget states are insensitive, prelighted, etc.
+     *
+     * This function accepts the values [flags@Gtk.StateFlags.dir-ltr] and
+     * [flags@Gtk.StateFlags.dir-rtl] but ignores them. If you want to set
+     * the widget's direction, use [method@Gtk.Widget.set_direction].
+     *
+     * This function is for use in widget implementations.
+     * @param flags - state flags to turn on
+     * @param clear - whether to clear state before turning on @flags
+     */
     setStateFlags(flags, clear) {
         call("libgtk-4.so.1", "gtk_widget_set_state_flags", [
             {
@@ -1811,6 +3682,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the contents of the tooltip for widget.
+     *
+     * `markup` must contain Pango markup.
+     *
+     * This function will take care of setting the
+     * [property@Gtk.Widget:has-tooltip] as a side effect, and of the
+     * default handler for the [signal@Gtk.Widget::query-tooltip] signal.
+     *
+     * See also [method@Gtk.Tooltip.set_markup].
+     * @param markup - the contents of the tooltip for @widget
+     */
     setTooltipMarkup(markup) {
         call("libgtk-4.so.1", "gtk_widget_set_tooltip_markup", [
             {
@@ -1824,6 +3707,19 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the contents of the tooltip for the widget.
+     *
+     * If `text` contains any markup, it will be escaped.
+     *
+     * This function will take care of setting
+     * [property@Gtk.Widget:has-tooltip] as a side effect,
+     * and of the default handler for the
+     * [signal@Gtk.Widget::query-tooltip] signal.
+     *
+     * See also [method@Gtk.Tooltip.set_text].
+     * @param text - the contents of the tooltip for @widget
+     */
     setTooltipText(text) {
         call("libgtk-4.so.1", "gtk_widget_set_tooltip_text", [
             {
@@ -1837,6 +3733,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the vertical alignment of the widget.
+     * @param align - the vertical alignment
+     */
     setValign(align) {
         call("libgtk-4.so.1", "gtk_widget_set_valign", [
             {
@@ -1849,6 +3749,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the widget would like any available extra vertical
+     * space.
+     *
+     * See [method@Gtk.Widget.set_hexpand] for more detail.
+     * @param expand - whether to expand
+     */
     setVexpand(expand) {
         call("libgtk-4.so.1", "gtk_widget_set_vexpand", [
             {
@@ -1861,6 +3768,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether the vexpand flag will be used.
+     *
+     * See [method@Gtk.Widget.set_hexpand_set] for more detail.
+     * @param set - value for vexpand-set property
+     */
     setVexpandSet(set) {
         call("libgtk-4.so.1", "gtk_widget_set_vexpand_set", [
             {
@@ -1873,6 +3786,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the visibility state of @widget.
+     *
+     * Note that setting this to true doesn’t mean the widget is
+     * actually viewable, see [method@Gtk.Widget.get_visible].
+     * @param visible - whether the widget should be shown or not
+     */
     setVisible(visible) {
         call("libgtk-4.so.1", "gtk_widget_set_visible", [
             {
@@ -1885,6 +3805,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Returns whether the widget should contribute to
+     * the measuring and allocation of its parent.
+     *
+     * This is false for invisible children, but also
+     * for children that have their own surface, such
+     * as [class@Gtk.Popover] instances.
+     */
     shouldLayout() {
         return call("libgtk-4.so.1", "gtk_widget_should_layout", [
             {
@@ -1893,6 +3821,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Flags a widget to be displayed.
+     *
+     * Any widget that isn’t shown will not appear on the screen.
+     *
+     * Remember that you have to show the containers containing a widget,
+     * in addition to the widget itself, before it will appear onscreen.
+     *
+     * When a toplevel widget is shown, it is immediately realized and
+     * mapped; other shown widgets are realized and mapped when their
+     * toplevel widget is realized and mapped.
+     */
     show() {
         call("libgtk-4.so.1", "gtk_widget_show", [
             {
@@ -1901,6 +3841,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Allocates widget with a transformation that translates
+     * the origin to the position in @allocation.
+     *
+     * This is a simple form of [method@Gtk.Widget.allocate].
+     * @param allocation - position and size to be allocated to @widget
+     * @param baseline - the baseline of the child, or -1
+     */
     sizeAllocate(allocation, baseline) {
         call("libgtk-4.so.1", "gtk_widget_size_allocate", [
             {
@@ -1917,6 +3865,24 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Snapshots a child of the widget.
+     *
+     * When a widget receives a call to the snapshot function,
+     * it must send synthetic [vfunc@Gtk.Widget.snapshot] calls
+     * to all children. This function provides a convenient way
+     * of doing this. A widget, when it receives a call to its
+     * [vfunc@Gtk.Widget.snapshot] function, calls
+     * gtk_widget_snapshot_child() once for each child, passing in
+     * the `snapshot` the widget received.
+     *
+     * This function takes care of translating the origin of @snapshot,
+     * and deciding whether the child needs to be snapshot.
+     *
+     * It does nothing for children that implement `GtkNative`.
+     * @param child - a child of @widget
+     * @param snapshot - snapshot as passed to the widget. In particular, no
+     */
     snapshotChild(child, snapshot) {
         call("libgtk-4.so.1", "gtk_widget_snapshot_child", [
             {
@@ -1933,6 +3899,18 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Translates coordinates relative to @src_widget’s allocation
+     * to coordinates relative to @dest_widget’s allocations.
+     *
+     * In order to perform this operation, both widget must share
+     * a common ancestor. If that is not the case, `dest_x` and `dest_y` are set to 0 and false is returned.
+     * @param destWidget - another widget
+     * @param srcX - X position in widget coordinates of @src_widget
+     * @param srcY - Y position in widget coordinates of @src_widget
+     * @param destX - location to store X position in widget coordinates of @dest_widget
+     * @param destY - location to store Y position in widget coordinates of @dest_widget
+     */
     translateCoordinates(destWidget, srcX, srcY, destX, destY) {
         return call("libgtk-4.so.1", "gtk_widget_translate_coordinates", [
             {
@@ -1963,6 +3941,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Triggers a tooltip query on the display of the widget.
+     */
     triggerTooltipQuery() {
         call("libgtk-4.so.1", "gtk_widget_trigger_tooltip_query", [
             {
@@ -1971,6 +3952,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Causes a widget to be unmapped if it’s currently mapped.
+     *
+     * This function is only for use in widget implementations.
+     */
     unmap() {
         call("libgtk-4.so.1", "gtk_widget_unmap", [
             {
@@ -1979,6 +3965,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes `widget` from its parent.
+     *
+     * This function is only for use in widget implementations,
+     * typically in dispose.
+     */
     unparent() {
         call("libgtk-4.so.1", "gtk_widget_unparent", [
             {
@@ -1987,6 +3979,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Causes a widget to be unrealized.
+     *
+     * This frees all GDK resources associated with the widget.
+     *
+     * This function is only useful in widget implementations.
+     */
     unrealize() {
         call("libgtk-4.so.1", "gtk_widget_unrealize", [
             {
@@ -1995,6 +3994,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Turns off flag values for the current widget state.
+     *
+     * See [method@Gtk.Widget.set_state_flags].
+     *
+     * This function is for use in widget implementations.
+     * @param flags - state flags to turn off
+     */
     unsetStateFlags(flags) {
         call("libgtk-4.so.1", "gtk_widget_unset_state_flags", [
             {
@@ -2007,6 +4014,19 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Requests the user's screen reader to announce the given message.
+     *
+     * This kind of notification is useful for messages that
+     * either have only a visual representation or that are not
+     * exposed visually at all, e.g. a notification about a
+     * successful operation.
+     *
+     * Also, by using this API, you can ensure that the message
+     * does not interrupts the user's current screen reader output.
+     * @param message - the string to announce
+     * @param priority - the priority of the announcement
+     */
     announce(message, priority) {
         call("libgtk-4.so.1", "gtk_accessible_announce", [
             {
@@ -2023,6 +4043,11 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the accessible parent for an accessible object.
+     *
+     * This function returns `NULL` for top level widgets.
+     */
     getAccessibleParent() {
         const ptr = call("libgtk-4.so.1", "gtk_accessible_get_accessible_parent", [
             {
@@ -2034,6 +4059,9 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Accessible);
     }
+    /**
+     * Retrieves the accessible role of an accessible object.
+     */
     getAccessibleRole() {
         return call("libgtk-4.so.1", "gtk_accessible_get_accessible_role", [
             {
@@ -2042,6 +4070,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the implementation for the given accessible object.
+     */
     getAtContext() {
         const ptr = call("libgtk-4.so.1", "gtk_accessible_get_at_context", [
             {
@@ -2051,6 +4082,17 @@ export class Widget extends GObject.InitiallyUnowned {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, ATContext);
     }
+    /**
+     * Queries the coordinates and dimensions of this accessible
+     *
+     * This functionality can be overridden by `GtkAccessible`
+     * implementations, e.g. to get the bounds from an ignored
+     * child widget.
+     * @param x - the x coordinate of the top left corner of the accessible
+     * @param y - the y coordinate of the top left corner of the widget
+     * @param width - the width of the accessible object
+     * @param height - the height of the accessible object
+     */
     getBounds(x, y, width, height) {
         return call("libgtk-4.so.1", "gtk_accessible_get_bounds", [
             {
@@ -2087,6 +4129,9 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the first accessible child of an accessible object.
+     */
     getFirstAccessibleChild() {
         const ptr = call("libgtk-4.so.1", "gtk_accessible_get_first_accessible_child", [
             {
@@ -2098,6 +4143,9 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Accessible);
     }
+    /**
+     * Retrieves the next accessible sibling of an accessible object
+     */
     getNextAccessibleSibling() {
         const ptr = call("libgtk-4.so.1", "gtk_accessible_get_next_accessible_sibling", [
             {
@@ -2109,6 +4157,14 @@ export class Widget extends GObject.InitiallyUnowned {
             return null;
         return getObject(ptr, Accessible);
     }
+    /**
+     * Queries a platform state, such as focus.
+     *
+     * This functionality can be overridden by `GtkAccessible`
+     * implementations, e.g. to get platform state from an ignored
+     * child widget, as is the case for `GtkText` wrappers.
+     * @param state - platform state to query
+     */
     getPlatformState(state) {
         return call("libgtk-4.so.1", "gtk_accessible_get_platform_state", [
             {
@@ -2121,6 +4177,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Resets the accessible property to its default value.
+     * @param property - the accessible property
+     */
     resetProperty(property) {
         call("libgtk-4.so.1", "gtk_accessible_reset_property", [
             {
@@ -2133,6 +4193,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Resets the accessible relation to its default value.
+     * @param relation - the accessible relation
+     */
     resetRelation(relation) {
         call("libgtk-4.so.1", "gtk_accessible_reset_relation", [
             {
@@ -2145,6 +4209,10 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Resets the accessible state to its default value.
+     * @param state - the accessible state
+     */
     resetState(state) {
         call("libgtk-4.so.1", "gtk_accessible_reset_state", [
             {
@@ -2157,6 +4225,19 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the parent and sibling of an accessible object.
+     *
+     * This function is meant to be used by accessible implementations that are
+     * not part of the widget hierarchy, and but act as a logical bridge between
+     * widgets. For instance, if a widget creates an object that holds metadata
+     * for each child, and you want that object to implement the `GtkAccessible`
+     * interface, you will use this function to ensure that the parent of each
+     * child widget is the metadata object, and the parent of each metadata
+     * object is the container widget.
+     * @param parent - the parent accessible object
+     * @param nextSibling - the sibling accessible object
+     */
     setAccessibleParent(parent, nextSibling) {
         call("libgtk-4.so.1", "gtk_accessible_set_accessible_parent", [
             {
@@ -2175,6 +4256,13 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Updates the next accessible sibling.
+     *
+     * That might be useful when a new child of a custom accessible
+     * is created, and it needs to be linked to a previous child.
+     * @param newSibling - the new next accessible sibling to set
+     */
     updateNextAccessibleSibling(newSibling) {
         call("libgtk-4.so.1", "gtk_accessible_update_next_accessible_sibling", [
             {
@@ -2188,6 +4276,14 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Informs ATs that the platform state has changed.
+     *
+     * This function should be used by `GtkAccessible` implementations that
+     * have a platform state but are not widgets. Widgets handle platform
+     * states automatically.
+     * @param state - the platform state to update
+     */
     updatePlatformState(state) {
         call("libgtk-4.so.1", "gtk_accessible_update_platform_state", [
             {
@@ -2200,6 +4296,17 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Updates an array of accessible properties.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * property change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nProperties - the number of accessible properties to set
+     * @param properties - an array of accessible properties
+     * @param values - an array of `GValues`, one for each property
+     */
     updatePropertyValue(nProperties, properties, values) {
         call("libgtk-4.so.1", "gtk_accessible_update_property_value", [
             {
@@ -2230,6 +4337,17 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Updates an array of accessible relations.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * relation change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nRelations - the number of accessible relations to set
+     * @param relations - an array of accessible relations
+     * @param values - an array of `GValues`, one for each relation
+     */
     updateRelationValue(nRelations, relations, values) {
         call("libgtk-4.so.1", "gtk_accessible_update_relation_value", [
             {
@@ -2260,6 +4378,17 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Updates an array of accessible states.
+     *
+     * This function should be called by `GtkWidget` types whenever an accessible
+     * state change must be communicated to assistive technologies.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nStates - the number of accessible states to set
+     * @param states - an array of accessible states
+     * @param values - an array of `GValues`, one for each state
+     */
     updateStateValue(nStates, states, values) {
         call("libgtk-4.so.1", "gtk_accessible_update_state_value", [
             {
@@ -2290,6 +4419,12 @@ export class Widget extends GObject.InitiallyUnowned {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the ID of the `buildable` object.
+     *
+     * `GtkBuilder` sets the name based on the ID attribute
+     * of the `<object>` tag used to construct the @buildable.
+     */
     getBuildableId() {
         return call("libgtk-4.so.1", "gtk_buildable_get_buildable_id", [
             {