@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/nothing-action.d.ts

@@ -1,6 +1,13 @@
 import { ShortcutAction } from "./shortcut-action.js";
+/** Does nothing. */
 export declare class NothingAction extends ShortcutAction {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the nothing action.
+     *
+     * This is an action that does nothing and where
+     * activating it always fails.
+     */
     static get(): NothingAction;
 }

package/dist/generated/gtk/nothing-action.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { ShortcutAction } from "./shortcut-action.js";
+/** Does nothing. */
 export class NothingAction extends ShortcutAction {
     constructor(...args) {
         super(...args);
@@ -16,6 +17,12 @@ export class NothingAction extends ShortcutAction {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the nothing action.
+     *
+     * This is an action that does nothing and where
+     * activating it always fails.
+     */
     static get() {
         const ptr = call("libgtk-4.so.1", "gtk_nothing_action_get", [], {
             type: "gobject",

package/dist/generated/gtk/numeric-sorter.d.ts

@@ -2,13 +2,46 @@ import { SortType } from "./enums.js";
 import { Expression } from "./expression.js";
 import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
+/**
+ * Sorts items numerically.
+ *
+ * To obtain the numbers to compare, this sorter evaluates a
+ * [class@Gtk.Expression].
+ */
 export declare class NumericSorter extends Sorter {
+    /**
+     * Creates a new numeric sorter using the given @expression.
+     *
+     * Smaller numbers will be sorted first. You can call
+     * [method@Gtk.NumericSorter.set_sort_order] to change this.
+     * @param expression - The expression to evaluate
+     */
     constructor(expression?: Expression | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the expression that is evaluated to obtain numbers from items.
+     */
     getExpression(): Expression | null;
+    /**
+     * Gets whether this sorter will sort smaller numbers first.
+     */
     getSortOrder(): SortType;
+    /**
+     * Sets the expression that is evaluated to obtain numbers from items.
+     *
+     * Unless an expression is set on @self, the sorter will always
+     * compare items as invalid.
+     *
+     * The expression must have a return type that can be compared
+     * numerically, such as %G_TYPE_INT or %G_TYPE_DOUBLE.
+     * @param expression - a `GtkExpression`
+     */
     setExpression(expression?: Expression | null): void;
+    /**
+     * Sets whether to sort smaller numbers before larger ones.
+     * @param sortOrder - whether to sort smaller numbers first
+     */
     setSortOrder(sortOrder: SortType): void;
     connect(signal: "notify", handler: (self: NumericSorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/numeric-sorter.js

@@ -2,6 +2,12 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Expression } from "./expression.js";
 import { Sorter } from "./sorter.js";
+/**
+ * Sorts items numerically.
+ *
+ * To obtain the numbers to compare, this sorter evaluates a
+ * [class@Gtk.Expression].
+ */
 export class NumericSorter extends Sorter {
     constructor(...args) {
         super(...args);
@@ -16,6 +22,9 @@ export class NumericSorter extends Sorter {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the expression that is evaluated to obtain numbers from items.
+     */
     getExpression() {
         const ptr = call("libgtk-4.so.1", "gtk_numeric_sorter_get_expression", [
             {
@@ -27,6 +36,9 @@ export class NumericSorter extends Sorter {
             return null;
         return getObject(ptr, Expression);
     }
+    /**
+     * Gets whether this sorter will sort smaller numbers first.
+     */
     getSortOrder() {
         return call("libgtk-4.so.1", "gtk_numeric_sorter_get_sort_order", [
             {
@@ -35,6 +47,16 @@ export class NumericSorter extends Sorter {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the expression that is evaluated to obtain numbers from items.
+     *
+     * Unless an expression is set on @self, the sorter will always
+     * compare items as invalid.
+     *
+     * The expression must have a return type that can be compared
+     * numerically, such as %G_TYPE_INT or %G_TYPE_DOUBLE.
+     * @param expression - a `GtkExpression`
+     */
     setExpression(expression) {
         call("libgtk-4.so.1", "gtk_numeric_sorter_set_expression", [
             {
@@ -48,6 +70,10 @@ export class NumericSorter extends Sorter {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to sort smaller numbers before larger ones.
+     * @param sortOrder - whether to sort smaller numbers first
+     */
     setSortOrder(sortOrder) {
         call("libgtk-4.so.1", "gtk_numeric_sorter_set_sort_order", [
             {

package/dist/generated/gtk/object-expression.d.ts

@@ -1,8 +1,22 @@
 import * as GObject from "../gobject/index.js";
 import { Expression } from "./expression.js";
+/** A `GObject` value in a `GtkExpression`. */
 export declare class ObjectExpression extends Expression {
+    /**
+     * Creates an expression evaluating to the given `object` with a weak reference.
+     *
+     * Once the `object` is disposed, it will fail to evaluate.
+     *
+     * This expression is meant to break reference cycles.
+     *
+     * If you want to keep a reference to `object`, use [ctor@Gtk.ConstantExpression.new].
+     * @param object - object to watch
+     */
     constructor(object: GObject.GObject);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the object that the expression evaluates to.
+     */
     getObject(): GObject.GObject | null;
 }

package/dist/generated/gtk/object-expression.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GObject from "../gobject/index.js";
 import { Expression } from "./expression.js";
+/** A `GObject` value in a `GtkExpression`. */
 export class ObjectExpression extends Expression {
     constructor(...args) {
         super(...args);
@@ -15,6 +16,9 @@ export class ObjectExpression extends Expression {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the object that the expression evaluates to.
+     */
     getObject() {
         const ptr = call("libgtk-4.so.1", "gtk_object_expression_get_object", [
             {

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

@@ -1,8 +1,27 @@
 import { Orientation } from "./enums.js";
+/**
+ * An interface for widgets that can be oriented horizontally or vertically.
+ *
+ * `GtkOrientable` is more flexible in that it allows the orientation to be
+ * changed at runtime, allowing the widgets to “flip”.
+ *
+ * ## CSS nodes
+ *
+ * `GtkWidget` types implementing the `GtkOrientable` interface will
+ * automatically acquire the `horizontal` or `vertical` CSS class depending on
+ * the value of the [property@Gtk.Orientable:orientation] property.
+ */
 export declare class Orientable {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): Orientable;
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation(): Orientation;
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation: Orientation): void;
 }

package/dist/generated/gtk/orientable.js

@@ -1,4 +1,16 @@
 import { call } from "@gtkx/native";
+/**
+ * An interface for widgets that can be oriented horizontally or vertically.
+ *
+ * `GtkOrientable` is more flexible in that it allows the orientation to be
+ * changed at runtime, allowing the widgets to “flip”.
+ *
+ * ## CSS nodes
+ *
+ * `GtkWidget` types implementing the `GtkOrientable` interface will
+ * automatically acquire the `horizontal` or `vertical` CSS class depending on
+ * the value of the [property@Gtk.Orientable:orientation] property.
+ */
 export class Orientable {
     ptr;
     constructor(ptr) {
@@ -7,6 +19,9 @@ export class Orientable {
     static fromPtr(ptr) {
         return new Orientable(ptr);
     }
+    /**
+     * Retrieves the orientation of the @orientable.
+     */
     getOrientation() {
         return call("libgtk-4.so.1", "gtk_orientable_get_orientation", [
             {
@@ -15,6 +30,10 @@ export class Orientable {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the orientation of the @orientable.
+     * @param orientation - the orientable’s new orientation
+     */
     setOrientation(orientation) {
         call("libgtk-4.so.1", "gtk_orientable_set_orientation", [
             {

package/dist/generated/gtk/overlay-layout-child.d.ts

@@ -1,9 +1,24 @@
 import { LayoutChild } from "./layout-child.js";
+/** `GtkLayoutChild` subclass for children in a `GtkOverlayLayout`. */
 export declare class OverlayLayoutChild extends LayoutChild {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Retrieves whether the child is clipped.
+     */
     getClipOverlay(): boolean;
+    /**
+     * Retrieves whether the child is measured.
+     */
     getMeasure(): boolean;
+    /**
+     * Sets whether to clip this child.
+     * @param clipOverlay - whether to clip this child
+     */
     setClipOverlay(clipOverlay: boolean): void;
+    /**
+     * Sets whether to measure this child.
+     * @param measure - whether to measure this child
+     */
     setMeasure(measure: boolean): void;
 }

package/dist/generated/gtk/overlay-layout-child.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { LayoutChild } from "./layout-child.js";
+/** `GtkLayoutChild` subclass for children in a `GtkOverlayLayout`. */
 export class OverlayLayoutChild extends LayoutChild {
     constructor(...args) {
         super(...args);
@@ -11,6 +12,9 @@ export class OverlayLayoutChild extends LayoutChild {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Retrieves whether the child is clipped.
+     */
     getClipOverlay() {
         return call("libgtk-4.so.1", "gtk_overlay_layout_child_get_clip_overlay", [
             {
@@ -19,6 +23,9 @@ export class OverlayLayoutChild extends LayoutChild {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves whether the child is measured.
+     */
     getMeasure() {
         return call("libgtk-4.so.1", "gtk_overlay_layout_child_get_measure", [
             {
@@ -27,6 +34,10 @@ export class OverlayLayoutChild extends LayoutChild {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Sets whether to clip this child.
+     * @param clipOverlay - whether to clip this child
+     */
     setClipOverlay(clipOverlay) {
         call("libgtk-4.so.1", "gtk_overlay_layout_child_set_clip_overlay", [
             {
@@ -39,6 +50,10 @@ export class OverlayLayoutChild extends LayoutChild {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether to measure this child.
+     * @param measure - whether to measure this child
+     */
     setMeasure(measure) {
         call("libgtk-4.so.1", "gtk_overlay_layout_child_set_measure", [
             {

package/dist/generated/gtk/overlay-layout.d.ts

@@ -1,5 +1,17 @@
 import { LayoutManager } from "./layout-manager.js";
+/**
+ * The layout manager used by [class@Gtk.Overlay].
+ *
+ * It places widgets as overlays on top of the main child.
+ *
+ * This is not a reusable layout manager, since it expects its widget
+ * to be a `GtkOverlay`. It is only listed here so that its layout
+ * properties get documented.
+ */
 export declare class OverlayLayout extends LayoutManager {
+    /**
+     * Creates a new `GtkOverlayLayout` instance.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
 }

package/dist/generated/gtk/overlay-layout.js

@@ -1,6 +1,18 @@
 import { call } from "@gtkx/native";
 import { LayoutManager } from "./layout-manager.js";
+/**
+ * The layout manager used by [class@Gtk.Overlay].
+ *
+ * It places widgets as overlays on top of the main child.
+ *
+ * This is not a reusable layout manager, since it expects its widget
+ * to be a `GtkOverlay`. It is only listed here so that its layout
+ * properties get documented.
+ */
 export class OverlayLayout extends LayoutManager {
+    /**
+     * Creates a new `GtkOverlayLayout` instance.
+     */
     constructor(...args) {
         super(...args);
     }

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

@@ -2,15 +2,63 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { Widget } from "./widget.js";
 export declare class Overlay extends Widget {
+    /**
+     * Creates a new `GtkOverlay`.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Adds `widget` to @overlay.
+     *
+     * The widget will be stacked on top of the main widget
+     * added with [method@Gtk.Overlay.set_child].
+     *
+     * The position at which `widget` is placed is determined
+     * from its [property@Gtk.Widget:halign] and
+     * [property@Gtk.Widget:valign] properties.
+     * @param widget - a `GtkWidget` to be added to the container
+     */
     addOverlay(widget: Widget): void;
+    /**
+     * Gets the child widget of @overlay.
+     */
     getChild(): Widget | null;
+    /**
+     * Gets whether `widget` should be clipped within the parent.
+     * @param widget - an overlay child of `GtkOverlay`
+     */
     getClipOverlay(widget: Widget): boolean;
+    /**
+     * Gets whether @widget's size is included in the measurement of
+     * @overlay.
+     * @param widget - an overlay child of `GtkOverlay`
+     */
     getMeasureOverlay(widget: Widget): boolean;
+    /**
+     * Removes an overlay that was added with gtk_overlay_add_overlay().
+     * @param widget - a `GtkWidget` to be removed
+     */
     removeOverlay(widget: Widget): void;
+    /**
+     * Sets the child widget of @overlay.
+     * @param child - the child widget
+     */
     setChild(child?: Widget | null): void;
+    /**
+     * Sets whether `widget` should be clipped within the parent.
+     * @param widget - an overlay child of `GtkOverlay`
+     * @param clipOverlay - whether the child should be clipped
+     */
     setClipOverlay(widget: Widget, clipOverlay: boolean): void;
+    /**
+     * Sets whether `widget` is included in the measured size of @overlay.
+     *
+     * The overlay will request the size of the largest child that has
+     * this property set to %TRUE. Children who are not included may
+     * be drawn outside of @overlay's allocation if they are too large.
+     * @param widget - an overlay child of `GtkOverlay`
+     * @param measure - whether the child should be measured
+     */
     setMeasureOverlay(widget: Widget, measure: boolean): void;
     connect(signal: "get-child-position", handler: (self: Overlay, widget: Widget, allocation: Gdk.Rectangle) => boolean, after?: boolean): number;
     connect(signal: "notify", handler: (self: Overlay, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/gtk/overlay.js

@@ -1,6 +1,39 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
+/**
+ * Places “overlay” widgets on top of a single main child.
+ *
+ *
+ *
+ * The position of each overlay widget is determined by its
+ * [property@Gtk.Widget:halign] and [property@Gtk.Widget:valign]
+ * properties. E.g. a widget with both alignments set to %GTK_ALIGN_START
+ * will be placed at the top left corner of the `GtkOverlay` container,
+ * whereas an overlay with halign set to %GTK_ALIGN_CENTER and valign set
+ * to %GTK_ALIGN_END will be placed a the bottom edge of the `GtkOverlay`,
+ * horizontally centered. The position can be adjusted by setting the margin
+ * properties of the child to non-zero values.
+ *
+ * More complicated placement of overlays is possible by connecting
+ * to the [signal@Gtk.Overlay::get-child-position] signal.
+ *
+ * An overlay’s minimum and natural sizes are those of its main child.
+ * The sizes of overlay children are not considered when measuring these
+ * preferred sizes.
+ *
+ * # GtkOverlay as GtkBuildable
+ *
+ * The `GtkOverlay` implementation of the `GtkBuildable` interface
+ * supports placing a child as an overlay by specifying “overlay” as
+ * the “type” attribute of a `<child>` element.
+ *
+ * # CSS nodes
+ *
+ * `GtkOverlay` has a single CSS node with the name “overlay”. Overlay children
+ * whose alignments cause them to be positioned at an edge get the style classes
+ * “.left”, “.right”, “.top”, and/or “.bottom” according to their position.
+ */
 const SIGNAL_META = {
     "get-child-position": {
         params: [
@@ -20,6 +53,9 @@ const SIGNAL_META = {
     },
 };
 export class Overlay extends Widget {
+    /**
+     * Creates a new `GtkOverlay`.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -29,6 +65,17 @@ export class Overlay extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Adds `widget` to @overlay.
+     *
+     * The widget will be stacked on top of the main widget
+     * added with [method@Gtk.Overlay.set_child].
+     *
+     * The position at which `widget` is placed is determined
+     * from its [property@Gtk.Widget:halign] and
+     * [property@Gtk.Widget:valign] properties.
+     * @param widget - a `GtkWidget` to be added to the container
+     */
     addOverlay(widget) {
         call("libgtk-4.so.1", "gtk_overlay_add_overlay", [
             {
@@ -41,6 +88,9 @@ export class Overlay extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the child widget of @overlay.
+     */
     getChild() {
         const ptr = call("libgtk-4.so.1", "gtk_overlay_get_child", [
             {
@@ -52,6 +102,10 @@ export class Overlay extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets whether `widget` should be clipped within the parent.
+     * @param widget - an overlay child of `GtkOverlay`
+     */
     getClipOverlay(widget) {
         return call("libgtk-4.so.1", "gtk_overlay_get_clip_overlay", [
             {
@@ -64,6 +118,11 @@ export class Overlay extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets whether @widget's size is included in the measurement of
+     * @overlay.
+     * @param widget - an overlay child of `GtkOverlay`
+     */
     getMeasureOverlay(widget) {
         return call("libgtk-4.so.1", "gtk_overlay_get_measure_overlay", [
             {
@@ -76,6 +135,10 @@ export class Overlay extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Removes an overlay that was added with gtk_overlay_add_overlay().
+     * @param widget - a `GtkWidget` to be removed
+     */
     removeOverlay(widget) {
         call("libgtk-4.so.1", "gtk_overlay_remove_overlay", [
             {
@@ -88,6 +151,10 @@ export class Overlay extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the child widget of @overlay.
+     * @param child - the child widget
+     */
     setChild(child) {
         call("libgtk-4.so.1", "gtk_overlay_set_child", [
             {
@@ -101,6 +168,11 @@ export class Overlay extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether `widget` should be clipped within the parent.
+     * @param widget - an overlay child of `GtkOverlay`
+     * @param clipOverlay - whether the child should be clipped
+     */
     setClipOverlay(widget, clipOverlay) {
         call("libgtk-4.so.1", "gtk_overlay_set_clip_overlay", [
             {
@@ -117,6 +189,15 @@ export class Overlay extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets whether `widget` is included in the measured size of @overlay.
+     *
+     * The overlay will request the size of the largest child that has
+     * this property set to %TRUE. Children who are not included may
+     * be drawn outside of @overlay's allocation if they are too large.
+     * @param widget - an overlay child of `GtkOverlay`
+     * @param measure - whether the child should be measured
+     */
     setMeasureOverlay(widget, measure) {
         call("libgtk-4.so.1", "gtk_overlay_set_measure_overlay", [
             {

package/dist/generated/gtk/pad-controller.d.ts

@@ -2,10 +2,107 @@ import { PadActionType } from "./enums.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import { EventController } from "./event-controller.js";
+/**
+ * Handles input from the pads found in drawing tablets.
+ *
+ * Pads are the collection of buttons and tactile sensors often found around
+ * the stylus-sensitive area.
+ *
+ * These buttons and sensors have no implicit meaning, and by default they
+ * perform no action. `GtkPadController` is provided to map those to
+ * [iface@Gio.Action] objects, thus letting the application give them a more
+ * semantic meaning.
+ *
+ * Buttons and sensors are not constrained to triggering a single action,
+ * some %GDK_SOURCE_TABLET_PAD devices feature multiple "modes". All these
+ * input elements have one current mode, which may determine the final action
+ * being triggered.
+ *
+ * Pad devices often divide buttons and sensors into groups. All elements
+ * in a group share the same current mode, but different groups may have
+ * different modes. See [method@Gdk.DevicePad.get_n_groups] and
+ * [method@Gdk.DevicePad.get_group_n_modes].
+ *
+ * Each of the actions that a given button/strip/ring performs for a given mode
+ * is defined by a [struct@Gtk.PadActionEntry]. It contains an action name that
+ * will be looked up in the given [iface@Gio.ActionGroup] and activated whenever
+ * the specified input element and mode are triggered.
+ *
+ * A simple example of `GtkPadController` usage: Assigning button 1 in all
+ * modes and pad devices to an "invert-selection" action:
+ *
+ * ```c
+ * GtkPadActionEntry *pad_actions[] = {
+ * { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
+ * …
+ * };
+ *
+ * …
+ * action_group = g_simple_action_group_new ();
+ * action = g_simple_action_new ("pad-actions.invert-selection", NULL);
+ * g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
+ * g_action_map_add_action (G_ACTION_MAP (action_group), action);
+ * …
+ * pad_controller = gtk_pad_controller_new (action_group, NULL);
+ * ```
+ *
+ * The actions belonging to rings/strips/dials will be activated with a parameter
+ * of type %G_VARIANT_TYPE_DOUBLE bearing the value of the given axis, it
+ * is required that those are made stateful and accepting this `GVariantType`.
+ * For rings the value is the angle of the ring position in degrees with 0
+ * facing up. For strips the value is the absolute position on the strip, normalized
+ * to the [0.0, 1.0] range.
+ * For dials the value is the relative movement of the dial, normalized so that the
+ * value 120 represents one logical scroll wheel detent in the positive direction.
+ * Devices that support high-resolution scrolling may send events with fractions of
+ * 120 to signify a smaller motion.
+ */
 export declare class PadController extends EventController {
+    /**
+     * Creates a new `GtkPadController` that will associate events from `pad` to
+     * actions.
+     *
+     * A %NULL pad may be provided so the controller manages all pad devices
+     * generically, it is discouraged to mix `GtkPadController` objects with
+     * %NULL and non-%NULL `pad` argument on the same toplevel window, as execution
+     * order is not guaranteed.
+     *
+     * The `GtkPadController` is created with no mapped actions. In order to
+     * map pad events to actions, use [method@Gtk.PadController.set_action_entries]
+     * or [method@Gtk.PadController.set_action].
+     *
+     * Be aware that pad events will only be delivered to `GtkWindow`s, so adding
+     * a pad controller to any other type of widget will not have an effect.
+     * @param group - `GActionGroup` to trigger actions from
+     * @param pad - A %GDK_SOURCE_TABLET_PAD device, or %NULL to handle all pads
+     */
     constructor(group: Gio.ActionGroup, pad?: Gdk.Device | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Adds an individual action to @controller.
+     *
+     * This action will only be activated if the given button/ring/strip number
+     * in `index` is interacted while the current mode is @mode. -1 may be used
+     * for simple cases, so the action is triggered on all modes.
+     *
+     * The given `label` should be considered user-visible, so internationalization
+     * rules apply. Some windowing systems may be able to use those for user
+     * feedback.
+     * @param type - the type of pad feature that will trigger this action
+     * @param index - the 0-indexed button/ring/strip number that will trigger this action
+     * @param mode - the mode that will trigger this action, or -1 for all modes.
+     * @param label - Human readable description of this action, this string should
+     * @param actionName - action name that will be activated in the `GActionGroup`
+     */
     setAction(type: PadActionType, index: number, mode: number, label: string, actionName: string): void;
+    /**
+     * A convenience function to add a group of action entries on
+     * @controller.
+     *
+     * See [struct@Gtk.PadActionEntry] and [method@Gtk.PadController.set_action].
+     * @param entries - the action entries to set on @controller
+     * @param nEntries - the number of elements in @entries
+     */
     setActionEntries(entries: number[], nEntries: number): void;
 }