@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/event-controller-focus.d.ts

@@ -1,9 +1,18 @@
 import * as GObject from "../gobject/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerFocus extends EventController {
+    /**
+     * Creates a new event controller that will handle focus events.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns %TRUE if focus is within `self` or one of its children.
+     */
     containsFocus(): boolean;
+    /**
+     * Returns %TRUE if focus is within @self, but not one of its children.
+     */
     isFocus(): boolean;
     connect(signal: "enter", handler: (self: EventControllerFocus) => void, after?: boolean): number;
     connect(signal: "leave", handler: (self: EventControllerFocus) => void, after?: boolean): number;

package/dist/generated/gtk/event-controller-focus.js

@@ -1,11 +1,24 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { EventController } from "./event-controller.js";
+/**
+ * Tracks keyboard focus.
+ *
+ * The event controller offers [signal@Gtk.EventControllerFocus::enter]
+ * and [signal@Gtk.EventControllerFocus::leave] signals, as well as
+ * [property@Gtk.EventControllerFocus:is-focus] and
+ * [property@Gtk.EventControllerFocus:contains-focus] properties
+ * which are updated to reflect focus changes inside the widget hierarchy
+ * that is rooted at the controllers widget.
+ */
 const SIGNAL_META = {
     enter: { params: [], returnType: { type: "undefined" } },
     leave: { params: [], returnType: { type: "undefined" } },
 };
 export class EventControllerFocus extends EventController {
+    /**
+     * Creates a new event controller that will handle focus events.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -15,6 +28,9 @@ export class EventControllerFocus extends EventController {
             borrowed: false,
         });
     }
+    /**
+     * Returns %TRUE if focus is within `self` or one of its children.
+     */
     containsFocus() {
         return call("libgtk-4.so.1", "gtk_event_controller_focus_contains_focus", [
             {
@@ -23,6 +39,9 @@ export class EventControllerFocus extends EventController {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns %TRUE if focus is within @self, but not one of its children.
+     */
     isFocus() {
         return call("libgtk-4.so.1", "gtk_event_controller_focus_is_focus", [
             {

package/dist/generated/gtk/event-controller-key.d.ts

@@ -4,11 +4,35 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerKey extends EventController {
+    /**
+     * Creates a new event controller that will handle key events.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Forwards the current event of this `controller` to a @widget.
+     *
+     * This function can only be used in handlers for the
+     * [signal@Gtk.EventControllerKey::key-pressed],
+     * [signal@Gtk.EventControllerKey::key-released]
+     * or [signal@Gtk.EventControllerKey::modifiers] signals.
+     * @param widget - a `GtkWidget`
+     */
     forward(widget: Widget): boolean;
+    /**
+     * Gets the key group of the current event of this @controller.
+     *
+     * See [method@Gdk.KeyEvent.get_layout].
+     */
     getGroup(): number;
+    /**
+     * Gets the input method context of the key @controller.
+     */
     getImContext(): IMContext | null;
+    /**
+     * Sets the input method context of the key @controller.
+     * @param imContext - a `GtkIMContext`
+     */
     setImContext(imContext?: IMContext | null): void;
     connect(signal: "im-update", handler: (self: EventControllerKey) => void, after?: boolean): number;
     connect(signal: "key-pressed", handler: (self: EventControllerKey, keyval: number, keycode: number, state: Gdk.ModifierType) => boolean, after?: boolean): number;

package/dist/generated/gtk/event-controller-key.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { IMContext } from "./imcontext.js";
 import { EventController } from "./event-controller.js";
+/** Provides access to key events. */
 const SIGNAL_META = {
     "im-update": { params: [], returnType: { type: "undefined" } },
     "key-pressed": {
@@ -26,6 +27,9 @@ const SIGNAL_META = {
     },
 };
 export class EventControllerKey extends EventController {
+    /**
+     * Creates a new event controller that will handle key events.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -35,6 +39,15 @@ export class EventControllerKey extends EventController {
             borrowed: false,
         });
     }
+    /**
+     * Forwards the current event of this `controller` to a @widget.
+     *
+     * This function can only be used in handlers for the
+     * [signal@Gtk.EventControllerKey::key-pressed],
+     * [signal@Gtk.EventControllerKey::key-released]
+     * or [signal@Gtk.EventControllerKey::modifiers] signals.
+     * @param widget - a `GtkWidget`
+     */
     forward(widget) {
         return call("libgtk-4.so.1", "gtk_event_controller_key_forward", [
             {
@@ -47,6 +60,11 @@ export class EventControllerKey extends EventController {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the key group of the current event of this @controller.
+     *
+     * See [method@Gdk.KeyEvent.get_layout].
+     */
     getGroup() {
         return call("libgtk-4.so.1", "gtk_event_controller_key_get_group", [
             {
@@ -55,6 +73,9 @@ export class EventControllerKey extends EventController {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the input method context of the key @controller.
+     */
     getImContext() {
         const ptr = call("libgtk-4.so.1", "gtk_event_controller_key_get_im_context", [
             {
@@ -66,6 +87,10 @@ export class EventControllerKey extends EventController {
             return null;
         return getObject(ptr, IMContext);
     }
+    /**
+     * Sets the input method context of the key @controller.
+     * @param imContext - a `GtkIMContext`
+     */
     setImContext(imContext) {
         call("libgtk-4.so.1", "gtk_event_controller_key_set_im_context", [
             {

package/dist/generated/gtk/event-controller-legacy.d.ts

@@ -2,6 +2,9 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerLegacy extends EventController {
+    /**
+     * Creates a new legacy event controller.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "event", handler: (self: EventControllerLegacy, event: Gdk.Event) => boolean, after?: boolean): number;

package/dist/generated/gtk/event-controller-legacy.js

@@ -2,6 +2,12 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
+/**
+ * Provides raw access to the event stream.
+ *
+ * It should only be used as a last resort if none of the other event
+ * controllers or gestures do the job.
+ */
 const SIGNAL_META = {
     event: {
         params: [
@@ -11,6 +17,9 @@ const SIGNAL_META = {
     },
 };
 export class EventControllerLegacy extends EventController {
+    /**
+     * Creates a new legacy event controller.
+     */
     constructor(...args) {
         super(...args);
     }

package/dist/generated/gtk/event-controller-motion.d.ts

@@ -1,9 +1,18 @@
 import * as GObject from "../gobject/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerMotion extends EventController {
+    /**
+     * Creates a new event controller that will handle motion events.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns if a pointer is within `self` or one of its children.
+     */
     containsPointer(): boolean;
+    /**
+     * Returns if a pointer is within @self, but not one of its children.
+     */
     isPointer(): boolean;
     connect(signal: "enter", handler: (self: EventControllerMotion, x: number, y: number) => void, after?: boolean): number;
     connect(signal: "leave", handler: (self: EventControllerMotion) => void, after?: boolean): number;

package/dist/generated/gtk/event-controller-motion.js

@@ -1,6 +1,16 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { EventController } from "./event-controller.js";
+/**
+ * Tracks the pointer position.
+ *
+ * The event controller offers [signal@Gtk.EventControllerMotion::enter]
+ * and [signal@Gtk.EventControllerMotion::leave] signals, as well as
+ * [property@Gtk.EventControllerMotion:is-pointer] and
+ * [property@Gtk.EventControllerMotion:contains-pointer] properties
+ * which are updated to reflect changes in the pointer position as it
+ * moves over the widget.
+ */
 const SIGNAL_META = {
     enter: {
         params: [
@@ -19,6 +29,9 @@ const SIGNAL_META = {
     },
 };
 export class EventControllerMotion extends EventController {
+    /**
+     * Creates a new event controller that will handle motion events.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -28,6 +41,9 @@ export class EventControllerMotion extends EventController {
             borrowed: false,
         });
     }
+    /**
+     * Returns if a pointer is within `self` or one of its children.
+     */
     containsPointer() {
         return call("libgtk-4.so.1", "gtk_event_controller_motion_contains_pointer", [
             {
@@ -36,6 +52,9 @@ export class EventControllerMotion extends EventController {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns if a pointer is within @self, but not one of its children.
+     */
     isPointer() {
         return call("libgtk-4.so.1", "gtk_event_controller_motion_is_pointer", [
             {

package/dist/generated/gtk/event-controller-scroll.d.ts

@@ -3,11 +3,29 @@ import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { EventController } from "./event-controller.js";
 export declare class EventControllerScroll extends EventController {
+    /**
+     * Creates a new event controller that will handle scroll events.
+     * @param flags - flags affecting the controller behavior
+     */
     constructor(flags: EventControllerScrollFlags);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the flags conditioning the scroll controller behavior.
+     */
     getFlags(): EventControllerScrollFlags;
+    /**
+     * Gets the scroll unit of the last
+     * [signal@Gtk.EventControllerScroll::scroll] signal received.
+     *
+     * Always returns %GDK_SCROLL_UNIT_WHEEL if the
+     * %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag is set.
+     */
     getUnit(): Gdk.ScrollUnit;
+    /**
+     * Sets the flags conditioning scroll controller behavior.
+     * @param flags - flags affecting the controller behavior
+     */
     setFlags(flags: EventControllerScrollFlags): void;
     connect(signal: "decelerate", handler: (self: EventControllerScroll, velX: number, velY: number) => void, after?: boolean): number;
     connect(signal: "scroll", handler: (self: EventControllerScroll, dx: number, dy: number) => boolean, after?: boolean): number;

package/dist/generated/gtk/event-controller-scroll.js

@@ -1,6 +1,41 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { EventController } from "./event-controller.js";
+/**
+ * Handles scroll events.
+ *
+ * It is capable of handling both discrete and continuous scroll
+ * events from mice or touchpads, abstracting them both with the
+ * [signal@Gtk.EventControllerScroll::scroll] signal. Deltas in
+ * the discrete case are multiples of 1.
+ *
+ * In the case of continuous scroll events, `GtkEventControllerScroll`
+ * encloses all [signal@Gtk.EventControllerScroll::scroll] emissions
+ * between two [signal@Gtk.EventControllerScroll::scroll-begin] and
+ * [signal@Gtk.EventControllerScroll::scroll-end] signals.
+ *
+ * The behavior of the event controller can be modified by the flags
+ * given at creation time, or modified at a later point through
+ * [method@Gtk.EventControllerScroll.set_flags] (e.g. because the scrolling
+ * conditions of the widget changed).
+ *
+ * The controller can be set up to emit motion for either/both vertical
+ * and horizontal scroll events through %GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
+ * %GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and %GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES.
+ * If any axis is disabled, the respective [signal@Gtk.EventControllerScroll::scroll]
+ * delta will be 0. Vertical scroll events will be translated to horizontal
+ * motion for the devices incapable of horizontal scrolling.
+ *
+ * The event controller can also be forced to emit discrete events on all
+ * devices through %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used
+ * to implement discrete actions triggered through scroll events (e.g.
+ * switching across combobox options).
+ *
+ * The %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the
+ * [signal@Gtk.EventControllerScroll::decelerate] signal, emitted at the end
+ * of scrolling with two X/Y velocity arguments that are consistent with the
+ * motion that was received.
+ */
 const SIGNAL_META = {
     decelerate: {
         params: [
@@ -32,6 +67,9 @@ export class EventControllerScroll extends EventController {
             },
         ], { type: "gobject", borrowed: false });
     }
+    /**
+     * Gets the flags conditioning the scroll controller behavior.
+     */
     getFlags() {
         return call("libgtk-4.so.1", "gtk_event_controller_scroll_get_flags", [
             {
@@ -40,6 +78,13 @@ export class EventControllerScroll extends EventController {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the scroll unit of the last
+     * [signal@Gtk.EventControllerScroll::scroll] signal received.
+     *
+     * Always returns %GDK_SCROLL_UNIT_WHEEL if the
+     * %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag is set.
+     */
     getUnit() {
         return call("libgtk-4.so.1", "gtk_event_controller_scroll_get_unit", [
             {
@@ -48,6 +93,10 @@ export class EventControllerScroll extends EventController {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets the flags conditioning scroll controller behavior.
+     * @param flags - flags affecting the controller behavior
+     */
     setFlags(flags) {
         call("libgtk-4.so.1", "gtk_event_controller_scroll_set_flags", [
             {

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

@@ -2,21 +2,96 @@ import { PropagationLimit, PropagationPhase } from "./enums.js";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
+/**
+ * The base class for event controllers.
+ *
+ * These are ancillary objects associated to widgets, which react
+ * to `GdkEvents`, and possibly trigger actions as a consequence.
+ *
+ * Event controllers are added to a widget with
+ * [method@Gtk.Widget.add_controller]. It is rarely necessary to
+ * explicitly remove a controller with [method@Gtk.Widget.remove_controller].
+ *
+ * See the chapter on input handling for
+ * an overview of the basic concepts, such as the capture and bubble
+ * phases of event propagation.
+ */
 export declare class EventController extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Returns the event that is currently being handled by the controller.
+     *
+     * At other times, %NULL is returned.
+     */
     getCurrentEvent(): Gdk.Event | null;
+    /**
+     * Returns the device of the event that is currently being
+     * handled by the controller.
+     *
+     * At other times, %NULL is returned.
+     */
     getCurrentEventDevice(): Gdk.Device | null;
+    /**
+     * Returns the modifier state of the event that is currently being
+     * handled by the controller.
+     *
+     * At other times, 0 is returned.
+     */
     getCurrentEventState(): Gdk.ModifierType;
+    /**
+     * Returns the timestamp of the event that is currently being
+     * handled by the controller.
+     *
+     * At other times, 0 is returned.
+     */
     getCurrentEventTime(): number;
+    /**
+     * Gets the name of @controller.
+     */
     getName(): string | null;
+    /**
+     * Gets the propagation limit of the event controller.
+     */
     getPropagationLimit(): PropagationLimit;
+    /**
+     * Gets the propagation phase at which `controller` handles events.
+     */
     getPropagationPhase(): PropagationPhase;
+    /**
+     * Returns the `GtkWidget` this controller relates to.
+     */
     getWidget(): Widget | null;
+    /**
+     * Resets the `controller` to a clean state.
+     */
     reset(): void;
+    /**
+     * Sets a name on the controller that can be used for debugging.
+     * @param name - a name for @controller
+     */
     setName(name?: string | null): void;
+    /**
+     * Sets the event propagation limit on the event controller.
+     *
+     * If the limit is set to %GTK_LIMIT_SAME_NATIVE, the controller
+     * won't handle events that are targeted at widgets on a different
+     * surface, such as popovers.
+     * @param limit - the propagation limit
+     */
     setPropagationLimit(limit: PropagationLimit): void;
+    /**
+     * Sets the propagation phase at which a controller handles events.
+     *
+     * If `phase` is %GTK_PHASE_NONE, no automatic event handling will be
+     * performed, but other additional gesture maintenance will.
+     * @param phase - a propagation phase
+     */
     setPropagationPhase(phase: PropagationPhase): void;
+    /**
+     * Sets a name on the controller that can be used for debugging.
+     * @param name - a name for @controller, must be a static string
+     */
     setStaticName(name?: string | null): void;
     connect(signal: "notify", handler: (self: EventController, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gtk/event-controller.js

@@ -3,6 +3,20 @@ import { getObject } from "@gtkx/ffi";
 import { Widget } from "./widget.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
+/**
+ * The base class for event controllers.
+ *
+ * These are ancillary objects associated to widgets, which react
+ * to `GdkEvents`, and possibly trigger actions as a consequence.
+ *
+ * Event controllers are added to a widget with
+ * [method@Gtk.Widget.add_controller]. It is rarely necessary to
+ * explicitly remove a controller with [method@Gtk.Widget.remove_controller].
+ *
+ * See the chapter on input handling for
+ * an overview of the basic concepts, such as the capture and bubble
+ * phases of event propagation.
+ */
 export class EventController extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -18,6 +32,11 @@ export class EventController extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Returns the event that is currently being handled by the controller.
+     *
+     * At other times, %NULL is returned.
+     */
     getCurrentEvent() {
         const ptr = call("libgtk-4.so.1", "gtk_event_controller_get_current_event", [
             {
@@ -29,6 +48,12 @@ export class EventController extends GObject.GObject {
             return null;
         return getObject(ptr, Gdk.Event);
     }
+    /**
+     * Returns the device of the event that is currently being
+     * handled by the controller.
+     *
+     * At other times, %NULL is returned.
+     */
     getCurrentEventDevice() {
         const ptr = call("libgtk-4.so.1", "gtk_event_controller_get_current_event_device", [
             {
@@ -40,6 +65,12 @@ export class EventController extends GObject.GObject {
             return null;
         return getObject(ptr, Gdk.Device);
     }
+    /**
+     * Returns the modifier state of the event that is currently being
+     * handled by the controller.
+     *
+     * At other times, 0 is returned.
+     */
     getCurrentEventState() {
         return call("libgtk-4.so.1", "gtk_event_controller_get_current_event_state", [
             {
@@ -48,6 +79,12 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the timestamp of the event that is currently being
+     * handled by the controller.
+     *
+     * At other times, 0 is returned.
+     */
     getCurrentEventTime() {
         return call("libgtk-4.so.1", "gtk_event_controller_get_current_event_time", [
             {
@@ -56,6 +93,9 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Gets the name of @controller.
+     */
     getName() {
         return call("libgtk-4.so.1", "gtk_event_controller_get_name", [
             {
@@ -64,6 +104,9 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the propagation limit of the event controller.
+     */
     getPropagationLimit() {
         return call("libgtk-4.so.1", "gtk_event_controller_get_propagation_limit", [
             {
@@ -72,6 +115,9 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the propagation phase at which `controller` handles events.
+     */
     getPropagationPhase() {
         return call("libgtk-4.so.1", "gtk_event_controller_get_propagation_phase", [
             {
@@ -80,6 +126,9 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns the `GtkWidget` this controller relates to.
+     */
     getWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_event_controller_get_widget", [
             {
@@ -91,6 +140,9 @@ export class EventController extends GObject.GObject {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Resets the `controller` to a clean state.
+     */
     reset() {
         call("libgtk-4.so.1", "gtk_event_controller_reset", [
             {
@@ -99,6 +151,10 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a name on the controller that can be used for debugging.
+     * @param name - a name for @controller
+     */
     setName(name) {
         call("libgtk-4.so.1", "gtk_event_controller_set_name", [
             {
@@ -112,6 +168,14 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the event propagation limit on the event controller.
+     *
+     * If the limit is set to %GTK_LIMIT_SAME_NATIVE, the controller
+     * won't handle events that are targeted at widgets on a different
+     * surface, such as popovers.
+     * @param limit - the propagation limit
+     */
     setPropagationLimit(limit) {
         call("libgtk-4.so.1", "gtk_event_controller_set_propagation_limit", [
             {
@@ -124,6 +188,13 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the propagation phase at which a controller handles events.
+     *
+     * If `phase` is %GTK_PHASE_NONE, no automatic event handling will be
+     * performed, but other additional gesture maintenance will.
+     * @param phase - a propagation phase
+     */
     setPropagationPhase(phase) {
         call("libgtk-4.so.1", "gtk_event_controller_set_propagation_phase", [
             {
@@ -136,6 +207,10 @@ export class EventController extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets a name on the controller that can be used for debugging.
+     * @param name - a name for @controller, must be a static string
+     */
     setStaticName(name) {
         call("libgtk-4.so.1", "gtk_event_controller_set_static_name", [
             {

package/dist/generated/gtk/every-filter.d.ts

@@ -1,6 +1,20 @@
 import * as GObject from "../gobject/index.js";
 import { MultiFilter } from "./multi-filter.js";
+/**
+ * Matches an item when each of its filters matches.
+ *
+ * To add filters to a `GtkEveryFilter`, use [method@Gtk.MultiFilter.append].
+ */
 export declare class EveryFilter extends MultiFilter {
+    /**
+     * Creates a new empty "every" filter.
+     *
+     * Use [method@Gtk.MultiFilter.append] to add filters to it.
+     *
+     * This filter matches an item if each of the filters added to it
+     * matches the item. In particular, this means that if no filter
+     * has been added to it, the filter matches every item.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
     connect(signal: "notify", handler: (self: EveryFilter, pspec: GObject.ParamSpec) => void, after?: boolean): number;

package/dist/generated/gtk/every-filter.js

@@ -1,7 +1,21 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { MultiFilter } from "./multi-filter.js";
+/**
+ * Matches an item when each of its filters matches.
+ *
+ * To add filters to a `GtkEveryFilter`, use [method@Gtk.MultiFilter.append].
+ */
 export class EveryFilter extends MultiFilter {
+    /**
+     * Creates a new empty "every" filter.
+     *
+     * Use [method@Gtk.MultiFilter.append] to add filters to it.
+     *
+     * This filter matches an item if each of the filters added to it
+     * matches the item. In particular, this means that if no filter
+     * has been added to it, the filter matches every item.
+     */
     constructor(...args) {
         super(...args);
     }