@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/search-entry.js

@@ -2,6 +2,60 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Editable } from "./editable.js";
 import { Widget } from "./widget.js";
+/**
+ * A single-line text entry widget for use as a search entry.
+ *
+ * The main API for interacting with a `GtkSearchEntry` as entry
+ * is the `GtkEditable` interface.
+ *
+ *
+ *
+ * It will show an inactive symbolic “find” icon when the search
+ * entry is empty, and a symbolic “clear” icon when there is text.
+ * Clicking on the “clear” icon will empty the search entry.
+ *
+ * To make filtering appear more reactive, it is a good idea to
+ * not react to every change in the entry text immediately, but
+ * only after a short delay. To support this, `GtkSearchEntry`
+ * emits the [signal@Gtk.SearchEntry::search-changed] signal which
+ * can be used instead of the [signal@Gtk.Editable::changed] signal.
+ *
+ * The [signal@Gtk.SearchEntry::previous-match],
+ * [signal@Gtk.SearchEntry::next-match] and
+ * [signal@Gtk.SearchEntry::stop-search] signals can be used to
+ * implement moving between search results and ending the search.
+ *
+ * Often, `GtkSearchEntry` will be fed events by means of being
+ * placed inside a [class@Gtk.SearchBar]. If that is not the case,
+ * you can use [method@Gtk.SearchEntry.set_key_capture_widget] to
+ * let it capture key input from another widget.
+ *
+ * `GtkSearchEntry` provides only minimal API and should be used with
+ * the [iface@Gtk.Editable] API.
+ *
+ * ## Shortcuts and Gestures
+ *
+ * The following signals have default keybindings:
+ *
+ * - [signal@Gtk.SearchEntry::activate]
+ * - [signal@Gtk.SearchEntry::next-match]
+ * - [signal@Gtk.SearchEntry::previous-match]
+ * - [signal@Gtk.SearchEntry::stop-search]
+ *
+ * ## CSS Nodes
+ *
+ * ```
+ * entry.search
+ * ╰── text
+ * ```
+ *
+ * `GtkSearchEntry` has a single CSS node with name entry that carries
+ * a `.search` style class, and the text node is a child of that.
+ *
+ * ## Accessibility
+ *
+ * `GtkSearchEntry` uses the [enum@Gtk.AccessibleRole.search_box] role.
+ */
 const SIGNAL_META = {
     activate: { params: [], returnType: { type: "undefined" } },
     "next-match": { params: [], returnType: { type: "undefined" } },
@@ -11,6 +65,9 @@ const SIGNAL_META = {
     "stop-search": { params: [], returnType: { type: "undefined" } },
 };
 export class SearchEntry extends Widget {
+    /**
+     * Creates a `GtkSearchEntry`.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -20,6 +77,9 @@ export class SearchEntry extends Widget {
             borrowed: true,
         });
     }
+    /**
+     * Gets the input purpose for @entry.
+     */
     getInputHints() {
         return call("libgtk-4.so.1", "gtk_search_entry_get_input_hints", [
             {
@@ -28,6 +88,9 @@ export class SearchEntry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the input purpose of @entry.
+     */
     getInputPurpose() {
         return call("libgtk-4.so.1", "gtk_search_entry_get_input_purpose", [
             {
@@ -36,6 +99,9 @@ export class SearchEntry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Gets the widget that `entry` is capturing key events from.
+     */
     getKeyCaptureWidget() {
         const ptr = call("libgtk-4.so.1", "gtk_search_entry_get_key_capture_widget", [
             {
@@ -47,6 +113,9 @@ export class SearchEntry extends Widget {
             return null;
         return getObject(ptr, Widget);
     }
+    /**
+     * Gets the placeholder text associated with @entry.
+     */
     getPlaceholderText() {
         return call("libgtk-4.so.1", "gtk_search_entry_get_placeholder_text", [
             {
@@ -55,6 +124,10 @@ export class SearchEntry extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Get the delay to be used between the last keypress and the
+     * [signal@Gtk.SearchEntry::search-changed] signal being emitted.
+     */
     getSearchDelay() {
         return call("libgtk-4.so.1", "gtk_search_entry_get_search_delay", [
             {
@@ -63,6 +136,10 @@ export class SearchEntry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Sets the input hints for @entry.
+     * @param hints - the new input hints
+     */
     setInputHints(hints) {
         call("libgtk-4.so.1", "gtk_search_entry_set_input_hints", [
             {
@@ -75,6 +152,10 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the input purpose of @entry.
+     * @param purpose - the new input purpose
+     */
     setInputPurpose(purpose) {
         call("libgtk-4.so.1", "gtk_search_entry_set_input_purpose", [
             {
@@ -87,6 +168,26 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets `widget` as the widget that `entry` will capture key
+     * events from.
+     *
+     * Key events are consumed by the search entry to start or
+     * continue a search.
+     *
+     * If the entry is part of a `GtkSearchBar`, it is preferable
+     * to call [method@Gtk.SearchBar.set_key_capture_widget] instead,
+     * which will reveal the entry in addition to triggering the
+     * search entry.
+     *
+     * Note that despite the name of this function, the events
+     * are only 'captured' in the bubble phase, which means that
+     * editable child widgets of `widget` will receive text input
+     * before it gets captured. If that is not desired, you can
+     * capture and forward the events yourself with
+     * [method@Gtk.EventControllerKey.forward].
+     * @param widget - a `GtkWidget`
+     */
     setKeyCaptureWidget(widget) {
         call("libgtk-4.so.1", "gtk_search_entry_set_key_capture_widget", [
             {
@@ -100,6 +201,10 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the placeholder text associated with @entry.
+     * @param text - the text to set as a placeholder
+     */
     setPlaceholderText(text) {
         call("libgtk-4.so.1", "gtk_search_entry_set_placeholder_text", [
             {
@@ -113,6 +218,11 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Set the delay to be used between the last keypress and the
+     * [signal@Gtk.SearchEntry::search-changed] signal being emitted.
+     * @param delay - a delay in milliseconds
+     */
     setSearchDelay(delay) {
         call("libgtk-4.so.1", "gtk_search_entry_set_search_delay", [
             {
@@ -125,6 +235,41 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the accessible platform state from the editable delegate.
+     *
+     * This is an helper function to retrieve the accessible state for
+     * `GtkEditable` interface implementations using a delegate pattern.
+     *
+     * You should call this function in your editable widget implementation
+     * of the [vfunc@Gtk.Accessible.get_platform_state] virtual function, for
+     * instance:
+     *
+     * ```c
+     * static void
+     * accessible_interface_init (GtkAccessibleInterface *iface)
+     * {
+     * iface->get_platform_state = your_editable_get_accessible_platform_state;
+     * }
+     *
+     * static gboolean
+     * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+     * GtkAccessiblePlatformState state)
+     * {
+     * return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+     * }
+     * ```
+     *
+     * Note that the widget which is the delegate *must* be a direct child of
+     * this widget, otherwise your implementation of [vfunc@Gtk.Accessible.get_platform_state]
+     * might not even be called, as the platform change will originate from
+     * the parent of the delegate, and, as a result, will not work properly.
+     *
+     * So, if you can't ensure the direct child condition, you should give the
+     * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+     * change your tree to allow this function to work.
+     * @param state - what kind of accessible state to retrieve
+     */
     delegateGetAccessiblePlatformState(state) {
         return call("libgtk-4.so.1", "gtk_editable_delegate_get_accessible_platform_state", [
             {
@@ -137,6 +282,11 @@ export class SearchEntry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Deletes the currently selected text of the editable.
+     *
+     * This call doesn’t do anything if there is no selected text.
+     */
     deleteSelection() {
         call("libgtk-4.so.1", "gtk_editable_delete_selection", [
             {
@@ -145,6 +295,18 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Deletes a sequence of characters.
+     *
+     * The characters that are deleted are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is
+     * negative, then the characters deleted are those from `start_pos` to
+     * the end of the text.
+     *
+     * Note that the positions are specified in characters, not bytes.
+     * @param startPos - start position
+     * @param endPos - end position
+     */
     deleteText(startPos, endPos) {
         call("libgtk-4.so.1", "gtk_editable_delete_text", [
             {
@@ -161,6 +323,12 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Undoes the setup done by [method@Gtk.Editable.init_delegate].
+     *
+     * This is a helper function that should be called from dispose,
+     * before removing the delegate object.
+     */
     finishDelegate() {
         call("libgtk-4.so.1", "gtk_editable_finish_delegate", [
             {
@@ -169,6 +337,9 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Gets the alignment of the editable.
+     */
     getAlignment() {
         return call("libgtk-4.so.1", "gtk_editable_get_alignment", [
             {
@@ -177,6 +348,18 @@ export class SearchEntry extends Widget {
             },
         ], { type: "float", size: 32 });
     }
+    /**
+     * Retrieves a sequence of characters.
+     *
+     * The characters that are retrieved are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is negative,
+     * then the characters retrieved are those characters from `start_pos` to
+     * the end of the text.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - start of text
+     * @param endPos - end of text
+     */
     getChars(startPos, endPos) {
         return call("libgtk-4.so.1", "gtk_editable_get_chars", [
             {
@@ -193,6 +376,12 @@ export class SearchEntry extends Widget {
             },
         ], { type: "string" });
     }
+    /**
+     * Gets the `GtkEditable` that `editable` is delegating its
+     * implementation to.
+     *
+     * Typically, the delegate is a [class@Gtk.Text] widget.
+     */
     getDelegate() {
         const ptr = call("libgtk-4.so.1", "gtk_editable_get_delegate", [
             {
@@ -204,6 +393,9 @@ export class SearchEntry extends Widget {
             return null;
         return getObject(ptr, Editable);
     }
+    /**
+     * Retrieves whether `editable` is editable.
+     */
     getEditable() {
         return call("libgtk-4.so.1", "gtk_editable_get_editable", [
             {
@@ -212,6 +404,9 @@ export class SearchEntry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets if undo/redo actions are enabled for @editable
+     */
     getEnableUndo() {
         return call("libgtk-4.so.1", "gtk_editable_get_enable_undo", [
             {
@@ -220,6 +415,9 @@ export class SearchEntry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the desired maximum width of @editable, in characters.
+     */
     getMaxWidthChars() {
         return call("libgtk-4.so.1", "gtk_editable_get_max_width_chars", [
             {
@@ -228,6 +426,12 @@ export class SearchEntry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the current position of the cursor relative
+     * to the start of the content of the editable.
+     *
+     * Note that this position is in characters, not in bytes.
+     */
     getPosition() {
         return call("libgtk-4.so.1", "gtk_editable_get_position", [
             {
@@ -236,6 +440,17 @@ export class SearchEntry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Retrieves the selection bound of the editable.
+     *
+     * `start_pos` will be filled with the start of the selection and
+     * `end_pos` with end. If no text was selected both will be identical
+     * and %FALSE will be returned.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - location to store the starting position
+     * @param endPos - location to store the end position
+     */
     getSelectionBounds(startPos, endPos) {
         return call("libgtk-4.so.1", "gtk_editable_get_selection_bounds", [
             {
@@ -260,6 +475,11 @@ export class SearchEntry extends Widget {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Retrieves the contents of @editable.
+     *
+     * The returned string is owned by GTK and must not be modified or freed.
+     */
     getText() {
         return call("libgtk-4.so.1", "gtk_editable_get_text", [
             {
@@ -268,6 +488,10 @@ export class SearchEntry extends Widget {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Gets the number of characters of space reserved
+     * for the contents of the editable.
+     */
     getWidthChars() {
         return call("libgtk-4.so.1", "gtk_editable_get_width_chars", [
             {
@@ -276,6 +500,15 @@ export class SearchEntry extends Widget {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Sets up a delegate for `GtkEditable`.
+     *
+     * This is assuming that the get_delegate vfunc in the `GtkEditable`
+     * interface has been set up for the @editable's type.
+     *
+     * This is a helper function that should be called in instance init,
+     * after creating the delegate object.
+     */
     initDelegate() {
         call("libgtk-4.so.1", "gtk_editable_init_delegate", [
             {
@@ -284,6 +517,17 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Inserts `length` bytes of `text` into the contents of the
+     * widget, at position @position.
+     *
+     * Note that the position is in characters, not in bytes.
+     * The function updates `position` to point after the newly
+     * inserted text.
+     * @param text - the text to insert
+     * @param length - the length of the text in bytes, or -1
+     * @param position - location of the position text will be inserted at
+     */
     insertText(text, length, position) {
         call("libgtk-4.so.1", "gtk_editable_insert_text", [
             {
@@ -307,6 +551,18 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Selects a region of text.
+     *
+     * The characters that are selected are those characters at positions
+     * from `start_pos` up to, but not including @end_pos. If `end_pos` is
+     * negative, then the characters selected are those characters from
+     * `start_pos` to  the end of the text.
+     *
+     * Note that positions are specified in characters, not bytes.
+     * @param startPos - start of region
+     * @param endPos - end of region
+     */
     selectRegion(startPos, endPos) {
         call("libgtk-4.so.1", "gtk_editable_select_region", [
             {
@@ -323,6 +579,13 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the alignment for the contents of the editable.
+     *
+     * This controls the horizontal positioning of the contents when
+     * the displayed text is shorter than the width of the editable.
+     * @param xalign - The horizontal alignment, from 0 (left) to 1 (right).
+     */
     setAlignment(xalign) {
         call("libgtk-4.so.1", "gtk_editable_set_alignment", [
             {
@@ -335,6 +598,10 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Determines if the user can edit the text in the editable widget.
+     * @param isEditable - %TRUE if the user is allowed to edit the text
+     */
     setEditable(isEditable) {
         call("libgtk-4.so.1", "gtk_editable_set_editable", [
             {
@@ -347,6 +614,15 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * If enabled, changes to `editable` will be saved for undo/redo
+     * actions.
+     *
+     * This results in an additional copy of text changes and are not
+     * stored in secure memory. As such, undo is forcefully disabled
+     * when [property@Gtk.Text:visibility] is set to %FALSE.
+     * @param enableUndo - if undo/redo should be enabled
+     */
     setEnableUndo(enableUndo) {
         call("libgtk-4.so.1", "gtk_editable_set_enable_undo", [
             {
@@ -359,6 +635,10 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the desired maximum width in characters of @editable.
+     * @param nChars - the new desired maximum width, in characters
+     */
     setMaxWidthChars(nChars) {
         call("libgtk-4.so.1", "gtk_editable_set_max_width_chars", [
             {
@@ -371,6 +651,16 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the cursor position in the editable to the given value.
+     *
+     * The cursor is displayed before the character with the given (base 0)
+     * index in the contents of the editable. The value must be less than
+     * or equal to the number of characters in the editable. A value of -1
+     * indicates that the position should be set after the last character
+     * of the editable. Note that `position` is in characters, not in bytes.
+     * @param position - the position of the cursor
+     */
     setPosition(position) {
         call("libgtk-4.so.1", "gtk_editable_set_position", [
             {
@@ -383,6 +673,12 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Sets the text in the editable to the given value.
+     *
+     * This is replacing the current contents.
+     * @param text - the text to set
+     */
     setText(text) {
         call("libgtk-4.so.1", "gtk_editable_set_text", [
             {
@@ -395,6 +691,15 @@ export class SearchEntry extends Widget {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Changes the size request of the editable to be about the
+     * right size for `n_chars` characters.
+     *
+     * Note that it changes the size request, the size can still
+     * be affected by how you pack the widget into containers.
+     * If `n_chars` is -1, the size reverts to the default size.
+     * @param nChars - width in chars
+     */
     setWidthChars(nChars) {
         call("libgtk-4.so.1", "gtk_editable_set_width_chars", [
             {

package/dist/generated/gtk/section-model.d.ts

@@ -1,8 +1,54 @@
 import { Ref } from "@gtkx/native";
+/**
+ * An interface that adds support for sections to list models.
+ *
+ * A `GtkSectionModel` groups successive items into so-called sections. List widgets
+ * like `GtkListView` and `GtkGridView` then allow displaying section headers for
+ * these sections by installing a header factory.
+ *
+ * Many GTK list models support sections inherently, or they pass through the sections
+ * of a model they are wrapping.
+ *
+ * When the section groupings of a model change, the model will emit the
+ * [signal@Gtk.SectionModel::sections-changed] signal by calling the
+ * [method@Gtk.SectionModel.sections_changed] function. All sections in the given range
+ * then need to be queried again.
+ * The [signal@Gio.ListModel::items-changed] signal has the same effect, all sections in
+ * that range are invalidated, too.
+ */
 export declare class SectionModel {
     ptr: unknown;
     protected constructor(ptr: unknown);
     static fromPtr(ptr: unknown): SectionModel;
+    /**
+     * Query the section that covers the given position. The number of
+     * items in the section can be computed by `out_end - out_start`.
+     *
+     * If the position is larger than the number of items, a single
+     * range from n_items to G_MAXUINT will be returned.
+     * @param position - the position of the item to query
+     * @param outStart - the position of the first item in the section
+     * @param outEnd - the position of the first item not part of the section
+     */
     getSection(position: number, outStart: Ref<number>, outEnd: Ref<number>): void;
+    /**
+     * This function emits the [signal@Gtk.SectionModel::sections-changed]
+     * signal to notify about changes to sections.
+     *
+     * It must cover all positions that used to be a section start or that
+     * are now a section start. It does not have to cover all positions for
+     * which the section has changed.
+     *
+     * The [signal@Gio.ListModel::items-changed] implies the effect of the
+     * [signal@Gtk.SectionModel::sections-changed] signal for all the items
+     * it covers.
+     *
+     * It is recommended that when changes to the items cause section changes
+     * in a larger range, that the larger range is included in the emission
+     * of the [signal@Gio.ListModel::items-changed] instead of emitting
+     * two signals.
+     * @param position - the first changed item
+     * @param nItems - the number of changed items
+     */
     sectionsChanged(position: number, nItems: number): void;
 }

package/dist/generated/gtk/section-model.js

@@ -1,4 +1,21 @@
 import { call } from "@gtkx/native";
+/**
+ * An interface that adds support for sections to list models.
+ *
+ * A `GtkSectionModel` groups successive items into so-called sections. List widgets
+ * like `GtkListView` and `GtkGridView` then allow displaying section headers for
+ * these sections by installing a header factory.
+ *
+ * Many GTK list models support sections inherently, or they pass through the sections
+ * of a model they are wrapping.
+ *
+ * When the section groupings of a model change, the model will emit the
+ * [signal@Gtk.SectionModel::sections-changed] signal by calling the
+ * [method@Gtk.SectionModel.sections_changed] function. All sections in the given range
+ * then need to be queried again.
+ * The [signal@Gio.ListModel::items-changed] signal has the same effect, all sections in
+ * that range are invalidated, too.
+ */
 export class SectionModel {
     ptr;
     constructor(ptr) {
@@ -7,6 +24,16 @@ export class SectionModel {
     static fromPtr(ptr) {
         return new SectionModel(ptr);
     }
+    /**
+     * Query the section that covers the given position. The number of
+     * items in the section can be computed by `out_end - out_start`.
+     *
+     * If the position is larger than the number of items, a single
+     * range from n_items to G_MAXUINT will be returned.
+     * @param position - the position of the item to query
+     * @param outStart - the position of the first item in the section
+     * @param outEnd - the position of the first item not part of the section
+     */
     getSection(position, outStart, outEnd) {
         call("libgtk-4.so.1", "gtk_section_model_get_section", [
             {
@@ -33,6 +60,25 @@ export class SectionModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * This function emits the [signal@Gtk.SectionModel::sections-changed]
+     * signal to notify about changes to sections.
+     *
+     * It must cover all positions that used to be a section start or that
+     * are now a section start. It does not have to cover all positions for
+     * which the section has changed.
+     *
+     * The [signal@Gio.ListModel::items-changed] implies the effect of the
+     * [signal@Gtk.SectionModel::sections-changed] signal for all the items
+     * it covers.
+     *
+     * It is recommended that when changes to the items cause section changes
+     * in a larger range, that the larger range is included in the emission
+     * of the [signal@Gio.ListModel::items-changed] instead of emitting
+     * two signals.
+     * @param position - the first changed item
+     * @param nItems - the number of changed items
+     */
     sectionsChanged(position, nItems) {
         call("libgtk-4.so.1", "gtk_section_model_sections_changed", [
             {

package/dist/generated/gtk/selection-filter-model.d.ts

@@ -1,10 +1,28 @@
 import { SelectionModel } from "./selection-model.js";
 import * as GObject from "../gobject/index.js";
+/** A list model that presents the selection from a `GtkSelectionModel`. */
 export declare class SelectionFilterModel extends GObject.GObject {
+    /**
+     * Creates a new `GtkSelectionFilterModel` that will include the
+     * selected items from the underlying selection model.
+     * @param model - the selection model to filter
+     */
     constructor(model?: SelectionModel | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Gets the model currently filtered or %NULL if none.
+     */
     getModel(): SelectionModel | null;
+    /**
+     * Sets the model to be filtered.
+     *
+     * Note that GTK makes no effort to ensure that `model` conforms to
+     * the item type of @self. It assumes that the caller knows what they
+     * are doing and have set up an appropriate filter to ensure that item
+     * types match.
+     * @param model - The model to be filtered
+     */
     setModel(model?: SelectionModel | null): void;
     connect(signal: "notify", handler: (self: SelectionFilterModel, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;