@gtkx/ffi 0.10.5 → 0.11.1

package/dist/generated/gtk/widget.d.ts

@@ -2,11 +2,11 @@ import { Ref } from "@gtkx/native";
 import { AccessibleAnnouncementPriority, AccessiblePlatformState, AccessibleProperty, AccessibleRelation, AccessibleRole, AccessibleState, Align, DirectionType, Orientation, Overflow, PickFlags, SizeRequestMode, StateFlags, TextDirection } from "./enums.js";
 import { Requisition } from "./requisition.js";
 import { Accessible } from "./accessible.js";
-import { ATContext } from "./atcontext.js";
-import { EventController } from "./event-controller.js";
-import { LayoutManager } from "./layout-manager.js";
 import { Native } from "./native.js";
 import { Root } from "./root.js";
+import { ATContext } from "./at-context.js";
+import { EventController } from "./event-controller.js";
+import { LayoutManager } from "./layout-manager.js";
 import { Settings } from "./settings.js";
 import { Snapshot } from "./snapshot.js";
 import { StyleContext } from "./style-context.js";
@@ -19,6 +19,400 @@ import * as Graphene from "../graphene/index.js";
 import * as Gsk from "../gsk/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:
+ *
+ * - {@link Gtk.Widget.get_request_mode}
+ * - {@link 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 {@link 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
+ * {@link 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 {@link 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 {@link 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 {@link 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 {@link 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 {@link Gtk.Label} that does height-for-width word wrapping
+ * will not expect to have {@link 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 {@link Gtk.Widget.measure}
+ * inside your own {@link Gtk.Widget.size_allocate} implementation.
+ * These return a request adjusted by {@link 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 {@link Gtk.Widget.measure}; otherwise, you
+ * would not properly consider widget margins, {@link 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
+ * {@link 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 {@link 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 {@link 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 {@link Gtk.WidgetClass.set_template}.
+ *
+ * The interface description semantics expected in composite template descriptions
+ * is slightly different from regular {@link Gtk.Builder} XML.
+ *
+ * Unlike regular interface descriptions, {@link 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 {@link 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 {@link 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 {@link 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
+ * {@link 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
+ * {@link Gtk.WidgetClass.bind_template_child_full} (or one of its wrapper macros
+ * {@link Gtk.widget_class_bind_template_child} and {@link 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 {@link Gtk.WidgetClass.bind_template_callback_full} (or
+ * is wrapper macro {@link 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);
+ * }
+ * ```
+ */
 export declare class Widget extends GObject.InitiallyUnowned {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -33,14 +427,11 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * Sets the default reading direction for widgets.
      *
      * See {@link Gtk.Widget.set_direction}.
-     * @param dir - the new default direction, either {@link Gtk.TextDirection.ltr}
      */
     static setDefaultDirection(dir: TextDirection): void;
     /**
      * Enables or disables an action installed with
      * {@link Gtk.WidgetClass.install_action}.
-     * @param actionName - action name, such as "clipboard.paste"
-     * @param enabled - whether the action is now enabled
      */
     actionSetEnabled(actionName: string, enabled: boolean): void;
     /**
@@ -73,10 +464,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * The arguments must match the actions expected parameter type,
      * as returned by {@link Gio.Action.get_parameter_type}.
-     * @param name - the name of the action to activate
-     * @param args - parameters to use
      */
-    activateActionVariant(name: string, args?: GLib.Variant): boolean;
+    activateActionVariant(name: string, args?: GLib.Variant | null): boolean;
     /**
      * Activates the `default.activate` action for the widget.
      *
@@ -92,7 +481,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * You will usually want to call this function right after
      * creating any kind of {@link Gtk.EventController}.
-     * @param controller - an event controller that hasn't been
      */
     addController(controller: EventController): void;
     /**
@@ -103,7 +491,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * Use {@link Gtk.Widget.remove_css_class} to remove the
      * style again.
-     * @param cssClass - style class to add to `widget`, without the leading period
      */
     addCssClass(cssClass: string): void;
     /**
@@ -114,7 +501,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Widget): void;
     /**
@@ -129,12 +515,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * For a version that does not take a transform, see
      * {@link 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: number, height: number, baseline: number, transform?: Gsk.Transform): void;
+    allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
     /**
      * Called by widgets as the user moves around the window using
      * keyboard shortcuts.
@@ -156,7 +538,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * This function is used by custom widget implementations; if you're
      * writing an app, you’d use {@link Gtk.Widget.grab_focus} to move
      * the focus to a particular widget.
-     * @param direction - direction of focus movement
      */
     childFocus(direction: DirectionType): boolean;
     /**
@@ -172,8 +553,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Widget, outBounds: Graphene.Rect): boolean;
     /**
@@ -190,7 +569,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Orientation): boolean;
     /**
@@ -200,9 +578,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Widget, point: Graphene.Point, outPoint: Graphene.Point): boolean;
     /**
@@ -215,8 +590,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: Widget, outTransform: Graphene.Matrix): boolean;
     /**
@@ -224,8 +597,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: number, y: number): boolean;
     /**
@@ -247,9 +618,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * you need to re-create it when the widgets `PangoContext`
      * is replaced. This can be tracked by listening to changes
      * of the {@link Gtk.Widget.root} property on the widget.
-     * @param text - text to set on the layout
      */
-    createPangoLayout(text?: string): Pango.Layout;
+    createPangoLayout(text?: string | null): Pango.Layout;
     /**
      * Clears the template children for the widget.
      *
@@ -276,16 +646,9 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
      * }
      * ```
-     * @param widgetType - the type of the widget to finalize the template for
      */
     disposeTemplate(widgetType: number): void;
-    /**
-     * 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
-     */
+    /** Checks to see if a drag movement has passed the GTK drag threshold. */
     dragCheckThreshold(startX: number, startY: number, currentX: number, currentY: number): boolean;
     /**
      * Notifies the user about an input-related error on the widget.
@@ -336,7 +699,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Ref<number>): void;
     /**
@@ -349,7 +711,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * Note that unlike {@link Gtk.Widget.is_ancestor}, this function
      * considers `widget` to be an ancestor of itself.
-     * @param widgetType - ancestor type
      */
     getAncestor(widgetType: number): Widget | null;
     /**
@@ -367,9 +728,7 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * See {@link Gtk.Widget.set_can_focus}.
      */
     getCanFocus(): boolean;
-    /**
-     * Queries whether the widget can be the target of pointer events.
-     */
+    /** Queries whether the widget can be the target of pointer events. */
     getCanTarget(): boolean;
     /**
      * Gets the value set with {@link Gtk.Widget.set_child_visible}.
@@ -397,16 +756,11 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Gdk.RGBA): void;
-    /**
-     * Returns the list of style classes applied to the widget.
-     */
+    /** Returns the list of style classes applied to the widget. */
     getCssClasses(): string[];
-    /**
-     * Returns the CSS name of the widget.
-     */
+    /** Returns the CSS name of the widget. */
     getCssName(): string;
     /**
      * Gets the cursor set on the widget.
@@ -437,9 +791,7 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * This function is primarily meant for widget implementations.
      */
     getFirstChild(): Widget | null;
-    /**
-     * Returns the focus child of the widget.
-     */
+    /** Returns the focus child of the widget. */
     getFocusChild(): Widget | null;
     /**
      * Returns whether the widget should grab focus when it is clicked
@@ -501,9 +853,7 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * Baselines are not supported for horizontal alignment.
      */
     getHalign(): Align;
-    /**
-     * Returns the current value of the `has-tooltip` property.
-     */
+    /** Returns the current value of the `has-tooltip` property. */
     getHasTooltip(): boolean;
     /**
      * Returns the content height of the widget.
@@ -560,29 +910,17 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * See {@link Gtk.Widget.set_layout_manager}.
      */
     getLayoutManager(): LayoutManager | null;
-    /**
-     * Gets the value of the {@link Gtk.Widget.limit-events} property.
-     */
+    /** Gets the value of the {@link Gtk.Widget.limit-events} property. */
     getLimitEvents(): boolean;
-    /**
-     * Returns whether the widget is mapped.
-     */
+    /** Returns whether the widget is mapped. */
     getMapped(): boolean;
-    /**
-     * Gets the bottom margin of the widget.
-     */
+    /** Gets the bottom margin of the widget. */
     getMarginBottom(): number;
-    /**
-     * Gets the end margin of the widget.
-     */
+    /** Gets the end margin of the widget. */
     getMarginEnd(): number;
-    /**
-     * Gets the start margin of the widget.
-     */
+    /** Gets the start margin of the widget. */
     getMarginStart(): number;
-    /**
-     * Gets the top margin of the widget.
-     */
+    /** Gets the top margin of the widget. */
     getMarginTop(): number;
     /**
      * Retrieves the name of a widget.
@@ -611,9 +949,7 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * See {@link Gtk.Widget.set_opacity}.
      */
     getOpacity(): number;
-    /**
-     * Returns the widget’s overflow value.
-     */
+    /** Returns the widget’s overflow value. */
     getOverflow(): Overflow;
     /**
      * Gets a `PangoContext` that is configured for the widget.
@@ -629,9 +965,7 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * {@link Gtk.Widget.root} property on the widget.
      */
     getPangoContext(): Pango.Context;
-    /**
-     * Returns the parent widget of the widget.
-     */
+    /** Returns the parent widget of the widget. */
     getParent(): Widget | null;
     /**
      * Retrieves the minimum and natural size of a widget, taking
@@ -648,10 +982,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * required height for the minimum width.
      *
      * Use {@link 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?: Requisition, naturalSize?: Requisition): void;
+    getPreferredSize(minimumSize?: Requisition | null, naturalSize?: Requisition | null): void;
     /**
      * Returns the widget’s previous sibling.
      *
@@ -668,9 +1000,7 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * realized yet.
      */
     getPrimaryClipboard(): Gdk.Clipboard;
-    /**
-     * Determines whether the widget is realized.
-     */
+    /** Determines whether the widget is realized. */
     getRealized(): boolean;
     /**
      * Determines whether the widget is always treated as the default widget
@@ -748,7 +1078,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * To learn more about widget sizes, see the coordinate
      * system overview.
-     * @param orientation - the orientation to query
      */
     getSize(orientation: Orientation): number;
     /**
@@ -762,10 +1091,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * To get the size a widget will actually request, call
      * {@link Gtk.Widget.measure} instead of this function.
-     * @param width - return location for width
-     * @param height - return location for height
      */
-    getSizeRequest(width?: Ref<number>, height?: Ref<number>): void;
+    getSizeRequest(width?: Ref<number> | null, height?: Ref<number> | null): void;
     /**
      * Returns the widget state as a flag set.
      *
@@ -796,8 +1123,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: number, name: string): GObject.GObject;
     /**
@@ -816,9 +1141,7 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * this function will return the escaped text.
      */
     getTooltipText(): string | null;
-    /**
-     * Gets the vertical alignment of the widget.
-     */
+    /** Gets the vertical alignment of the widget. */
     getValign(): Align;
     /**
      * Gets whether the widget would like any available extra vertical
@@ -871,10 +1194,7 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * is allowed, should not have an effect, and return true.
      */
     grabFocus(): boolean;
-    /**
-     * Returns whether a style class is currently applied to the widget.
-     * @param cssClass - style class, without the leading period
-     */
+    /** Returns whether a style class is currently applied to the widget. */
     hasCssClass(cssClass: string): boolean;
     /**
      * Determines whether the widget is the current default widget
@@ -926,13 +1246,13 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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
+     *  - 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.
@@ -952,10 +1272,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: string, group?: Gio.ActionGroup): void;
+    insertActionGroup(name: string, group?: Gio.ActionGroup | null): void;
     /**
      * Sets the parent widget of the widget.
      *
@@ -975,10 +1293,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: Widget, previousSibling?: Widget): void;
+    insertAfter(parent: Widget, previousSibling?: Widget | null): void;
     /**
      * Sets the parent widget of the widget.
      *
@@ -997,14 +1313,9 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: Widget, nextSibling?: Widget): void;
-    /**
-     * Determines whether the widget is a descendent of `ancestor`.
-     * @param ancestor - another `GtkWidget`
      */
+    insertBefore(parent: Widget, nextSibling?: Widget | null): void;
+    /** Determines whether the widget is a descendent of `ancestor`. */
     isAncestor(ancestor: Widget): boolean;
     /**
      * Determines whether the widget can be drawn to.
@@ -1068,7 +1379,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * {@link 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: DirectionType): boolean;
     /**
@@ -1100,18 +1410,9 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: Orientation, forSize: number, minimum?: Ref<number>, natural?: Ref<number>, minimumBaseline?: Ref<number>, naturalBaseline?: Ref<number>): void;
-    /**
-     * Emits the {@link Gtk.Widget.:mnemonic-activate} signal.
-     * @param groupCycling - true if there are other widgets with the same mnemonic
      */
+    measure(orientation: Orientation, forSize: number, minimum?: Ref<number> | null, natural?: Ref<number> | null, minimumBaseline?: Ref<number> | null, naturalBaseline?: Ref<number> | null): void;
+    /** Emits the {@link Gtk.Widget.:mnemonic-activate} signal. */
     mnemonicActivate(groupCycling: boolean): boolean;
     /**
      * Returns a list model to track the children of the widget.
@@ -1150,9 +1451,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: number, y: number, flags: PickFlags): Widget | null;
     /**
@@ -1221,14 +1519,12 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: EventController): void;
     /**
      * 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: string): void;
     /**
@@ -1238,13 +1534,11 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * The widget must have previously been added to the list with
      * {@link Gtk.Widget.add_mnemonic_label}.
-     * @param label - a widget that is a mnemonic label for `widget`
      */
     removeMnemonicLabel(label: Widget): void;
     /**
      * Removes a tick callback previously registered with
      * {@link Gtk.Widget.add_tick_callback}.
-     * @param id - an ID returned by {@link Gtk.Widget.add_tick_callback}
      */
     removeTickCallback(id: number): void;
     /**
@@ -1262,13 +1556,9 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * See {@link Gtk.Widget.grab_focus} for actually setting
      * the input focus on a widget.
-     * @param canFocus - whether the input focus can enter
      */
     setCanFocus(canFocus: boolean): void;
-    /**
-     * Sets whether the widget can be the target of pointer events.
-     * @param canTarget - whether this widget should be able to
-     */
+    /** Sets whether the widget can be the target of pointer events. */
     setCanTarget(canTarget: boolean): void;
     /**
      * Sets whether the widget should be mapped along with its parent.
@@ -1287,13 +1577,9 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: boolean): void;
-    /**
-     * Replaces the current style classes of the widget with `classes`.
-     * @param classes - `NULL`-terminated list of style classes
-     */
+    /** Replaces the current style classes of the widget with `classes`. */
     setCssClasses(classes: string[]): void;
     /**
      * Sets the cursor to be shown when the pointer hovers over
@@ -1301,9 +1587,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * If the `cursor` is `NULL`, `widget` will use the cursor
      * inherited from its parent.
-     * @param cursor - the new cursor
      */
-    setCursor(cursor?: Gdk.Cursor): void;
+    setCursor(cursor?: Gdk.Cursor | null): void;
     /**
      * Sets the cursor to be shown when the pointer hovers over
      * the widget.
@@ -1316,9 +1601,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * On top of that, this function allows `name` to be `NULL`, which
      * will do the same as calling {@link Gtk.Widget.set_cursor}
      * with a `NULL` cursor.
-     * @param name - the name of the cursor
      */
-    setCursorFromName(name?: string): void;
+    setCursorFromName(name?: string | null): void;
     /**
      * Sets the reading direction on the widget.
      *
@@ -1335,7 +1619,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * If the direction is set to {@link Gtk.TextDirection.none}, then
      * the value set by {@link Gtk.Widget.set_default_direction} will be used.
-     * @param dir - the new direction
      */
     setDirection(dir: TextDirection): void;
     /**
@@ -1344,9 +1627,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * This function is only suitable for widget implementations.
      * If you want a certain widget to get the input focus, call
      * {@link Gtk.Widget.grab_focus} on it.
-     * @param child - a direct child widget of `widget`
      */
-    setFocusChild(child?: Widget): void;
+    setFocusChild(child?: Widget | null): void;
     /**
      * Sets whether the widget should grab focus when it is clicked
      * with the mouse.
@@ -1354,7 +1636,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: boolean): void;
     /**
@@ -1371,7 +1652,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * See {@link 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: boolean): void;
     /**
@@ -1383,27 +1663,19 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * of available fonts.
      *
      * When not set, the widget will inherit the font map from its parent.
-     * @param fontMap - a `PangoFontMap`
      */
-    setFontMap(fontMap?: Pango.FontMap): void;
+    setFontMap(fontMap?: Pango.FontMap | null): void;
     /**
      * 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?: cairo.FontOptions): void;
-    /**
-     * Sets the horizontal alignment of the widget.
-     * @param align - the horizontal alignment
      */
+    setFontOptions(options?: cairo.FontOptions | null): void;
+    /** Sets the horizontal alignment of the widget. */
     setHalign(align: Align): void;
-    /**
-     * Sets the `has-tooltip` property on the widget.
-     * @param hasTooltip - whether or not `widget` has a tooltip
-     */
+    /** Sets the `has-tooltip` property on the widget. */
     setHasTooltip(hasTooltip: boolean): void;
     /**
      * Sets whether the widget would like any available extra horizontal
@@ -1432,7 +1704,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * {@link Gtk.Widget.set_hexpand} sets the hexpand-set property (see
      * {@link 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: boolean): void;
     /**
@@ -1450,40 +1721,25 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: boolean): void;
     /**
      * Sets the layout manager to use for measuring and allocating children
      * of the widget.
-     * @param layoutManager - a layout manager
      */
-    setLayoutManager(layoutManager?: LayoutManager): void;
+    setLayoutManager(layoutManager?: LayoutManager | null): void;
     /**
      * Sets whether the widget acts like a modal dialog,
      * with respect to event delivery.
-     * @param limitEvents - whether to limit events
      */
     setLimitEvents(limitEvents: boolean): void;
-    /**
-     * Sets the bottom margin of the widget.
-     * @param margin - the bottom margin
-     */
+    /** Sets the bottom margin of the widget. */
     setMarginBottom(margin: number): void;
-    /**
-     * Sets the end margin of the widget.
-     * @param margin - the end margin
-     */
+    /** Sets the end margin of the widget. */
     setMarginEnd(margin: number): void;
-    /**
-     * Sets the start margin of the widget.
-     * @param margin - the start margin
-     */
+    /** Sets the start margin of the widget. */
     setMarginStart(margin: number): void;
-    /**
-     * Sets the top margin of the widget.
-     * @param margin - the top margin
-     */
+    /** Sets the top margin of the widget. */
     setMarginTop(margin: number): void;
     /**
      * Sets a widgets name.
@@ -1497,7 +1753,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: string): void;
     /**
@@ -1524,7 +1779,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: number): void;
     /**
@@ -1537,7 +1791,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * should not be used by application code.
      *
      * The default value is {@link Gtk.Overflow.visible}.
-     * @param overflow - desired overflow value
      */
     setOverflow(overflow: Overflow): void;
     /**
@@ -1549,14 +1802,12 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * This function is useful only when implementing subclasses of
      * `GtkWidget`.
-     * @param parent - parent widget
      */
     setParent(parent: Widget): void;
     /**
      * 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: boolean): void;
     /**
@@ -1566,7 +1817,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: boolean): void;
     /**
@@ -1604,8 +1854,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * {@link 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: number, height: number): void;
     /**
@@ -1618,8 +1866,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * the widget's direction, use {@link 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: StateFlags, clear: boolean): void;
     /**
@@ -1632,9 +1878,8 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * default handler for the {@link Gtk.Widget.:query-tooltip} signal.
      *
      * See also {@link Gtk.Tooltip.set_markup}.
-     * @param markup - the contents of the tooltip for `widget`
      */
-    setTooltipMarkup(markup?: string): void;
+    setTooltipMarkup(markup?: string | null): void;
     /**
      * Sets the contents of the tooltip for the widget.
      *
@@ -1646,27 +1891,21 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * {@link Gtk.Widget.:query-tooltip} signal.
      *
      * See also {@link Gtk.Tooltip.set_text}.
-     * @param text - the contents of the tooltip for `widget`
-     */
-    setTooltipText(text?: string): void;
-    /**
-     * Sets the vertical alignment of the widget.
-     * @param align - the vertical alignment
      */
+    setTooltipText(text?: string | null): void;
+    /** Sets the vertical alignment of the widget. */
     setValign(align: Align): void;
     /**
      * Sets whether the widget would like any available extra vertical
      * space.
      *
      * See {@link Gtk.Widget.set_hexpand} for more detail.
-     * @param expand - whether to expand
      */
     setVexpand(expand: boolean): void;
     /**
      * Sets whether the vexpand flag will be used.
      *
      * See {@link Gtk.Widget.set_hexpand_set} for more detail.
-     * @param set - value for vexpand-set property
      */
     setVexpandSet(set: boolean): void;
     /**
@@ -1674,7 +1913,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * Note that setting this to true doesn’t mean the widget is
      * actually viewable, see {@link Gtk.Widget.get_visible}.
-     * @param visible - whether the widget should be shown or not
      */
     setVisible(visible: boolean): void;
     /**
@@ -1704,8 +1942,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * the origin to the position in `allocation`.
      *
      * This is a simple form of {@link Gtk.Widget.allocate}.
-     * @param allocation - position and size to be allocated to `widget`
-     * @param baseline - the baseline of the child, or -1
      */
     sizeAllocate(allocation: number, baseline: number): void;
     /**
@@ -1723,8 +1959,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Widget, snapshot: Snapshot): void;
     /**
@@ -1734,16 +1968,9 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Widget, srcX: number, srcY: number, destX?: Ref<number>, destY?: Ref<number>): boolean;
-    /**
-     * Triggers a tooltip query on the display of the widget.
      */
+    translateCoordinates(destWidget: Widget, srcX: number, srcY: number, destX?: Ref<number> | null, destY?: Ref<number> | null): boolean;
+    /** Triggers a tooltip query on the display of the widget. */
     triggerTooltipQuery(): void;
     /**
      * Causes a widget to be unmapped if it’s currently mapped.
@@ -1772,7 +1999,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * See {@link Gtk.Widget.set_state_flags}.
      *
      * This function is for use in widget implementations.
-     * @param flags - state flags to turn off
      */
     unsetStateFlags(flags: StateFlags): void;
     /**
@@ -1785,8 +2011,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      *
      * 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: string, priority: AccessibleAnnouncementPriority): void;
     /**
@@ -1795,13 +2019,9 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * This function returns `NULL` for top level widgets.
      */
     getAccessibleParent(): Accessible | null;
-    /**
-     * Retrieves the accessible role of an accessible object.
-     */
+    /** Retrieves the accessible role of an accessible object. */
     getAccessibleRole(): AccessibleRole;
-    /**
-     * Retrieves the implementation for the given accessible object.
-     */
+    /** Retrieves the implementation for the given accessible object. */
     getAtContext(): ATContext;
     /**
      * Queries the coordinates and dimensions of this accessible
@@ -1809,19 +2029,11 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: Ref<number>, y: Ref<number>, width: Ref<number>, height: Ref<number>): boolean;
-    /**
-     * Retrieves the first accessible child of an accessible object.
-     */
+    /** Retrieves the first accessible child of an accessible object. */
     getFirstAccessibleChild(): Accessible | null;
-    /**
-     * Retrieves the next accessible sibling of an accessible object
-     */
+    /** Retrieves the next accessible sibling of an accessible object */
     getNextAccessibleSibling(): Accessible | null;
     /**
      * Queries a platform state, such as focus.
@@ -1829,23 +2041,13 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: AccessiblePlatformState): boolean;
-    /**
-     * Resets the accessible property to its default value.
-     * @param property - the accessible property
-     */
+    /** Resets the accessible property to its default value. */
     resetProperty(property: AccessibleProperty): void;
-    /**
-     * Resets the accessible relation to its default value.
-     * @param relation - the accessible relation
-     */
+    /** Resets the accessible relation to its default value. */
     resetRelation(relation: AccessibleRelation): void;
-    /**
-     * Resets the accessible state to its default value.
-     * @param state - the accessible state
-     */
+    /** Resets the accessible state to its default value. */
     resetState(state: AccessibleState): void;
     /**
      * Sets the parent and sibling of an accessible object.
@@ -1857,25 +2059,21 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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?: Accessible, nextSibling?: Accessible): void;
+    setAccessibleParent(parent?: Accessible | null, nextSibling?: Accessible | null): void;
     /**
      * 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?: Accessible): void;
+    updateNextAccessibleSibling(newSibling?: Accessible | null): void;
     /**
      * 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: AccessiblePlatformState): void;
     /**
@@ -1885,9 +2083,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: number, properties: AccessibleProperty[], values: GObject.Value[]): void;
     /**
@@ -1897,9 +2092,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: number, relations: AccessibleRelation[], values: GObject.Value[]): void;
     /**
@@ -1909,9 +2101,6 @@ export declare class Widget extends GObject.InitiallyUnowned {
      * 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: number, states: AccessibleState[], values: GObject.Value[]): void;
     /**
@@ -1934,6 +2123,5 @@ export declare class Widget extends GObject.InitiallyUnowned {
     connect(signal: "state-flags-changed", handler: (self: Widget, flags: StateFlags) => void, after?: boolean): number;
     connect(signal: "unmap", handler: (self: Widget) => void, after?: boolean): number;
     connect(signal: "unrealize", handler: (self: Widget) => void, after?: boolean): number;
-    connect(signal: "notify", handler: (self: Widget, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }