@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/list-store.d.ts

@@ -5,62 +5,642 @@ import { TreePath } from "./tree-path.js";
 import { TreeModel } from "./tree-model.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
+/**
+ * A list-like data structure that can be used with the [class@Gtk.TreeView].
+ *
+ * The `GtkListStore` object is a list model for use with a `GtkTreeView`
+ * widget.  It implements the `GtkTreeModel` interface, and consequentialy,
+ * can use all of the methods available there.  It also implements the
+ * `GtkTreeSortable` interface so it can be sorted by the view.
+ * Finally, it also implements the tree
+ * drag and drop
+ * interfaces.
+ *
+ * The `GtkListStore` can accept most `GType`s as a column type, though
+ * it can’t accept all custom types.  Internally, it will keep a copy of
+ * data passed in (such as a string or a boxed pointer).  Columns that
+ * accept `GObject`s are handled a little differently.  The
+ * `GtkListStore` will keep a reference to the object instead of copying the
+ * value.  As a result, if the object is modified, it is up to the
+ * application writer to call [method@Gtk.TreeModel.row_changed] to emit the
+ * [signal@Gtk.TreeModel::row_changed] signal. This most commonly affects lists
+ * with [class@Gdk.Texture]s stored.
+ *
+ * An example for creating a simple list store:
+ *
+ * ```c
+ * enum {
+ * COLUMN_STRING,
+ * COLUMN_INT,
+ * COLUMN_BOOLEAN,
+ * N_COLUMNS
+ * };
+ *
+ * {
+ * GtkListStore *list_store;
+ * GtkTreePath *path;
+ * GtkTreeIter iter;
+ * int i;
+ *
+ * list_store = gtk_list_store_new (N_COLUMNS,
+ * G_TYPE_STRING,
+ * G_TYPE_INT,
+ * G_TYPE_BOOLEAN);
+ *
+ * for (i = 0; i < 10; i++)
+ * {
+ * char *some_data;
+ *
+ * some_data = get_some_data (i);
+ *
+ * // Add a new row to the model
+ * gtk_list_store_append (list_store, &iter);
+ * gtk_list_store_set (list_store, &iter,
+ * COLUMN_STRING, some_data,
+ * COLUMN_INT, i,
+ * COLUMN_BOOLEAN,  FALSE,
+ * -1);
+ *
+ * // As the store will keep a copy of the string internally,
+ * // we free some_data.
+ * g_free (some_data);
+ * }
+ *
+ * // Modify a particular row
+ * path = gtk_tree_path_new_from_string ("4");
+ * gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store),
+ * &iter,
+ * path);
+ * gtk_tree_path_free (path);
+ * gtk_list_store_set (list_store, &iter,
+ * COLUMN_BOOLEAN, TRUE,
+ * -1);
+ * }
+ * ```
+ *
+ * `GtkListStore` is deprecated since GTK 4.10, and should not be used in newly
+ * written code. You should use [class@Gio.ListStore] instead, and the various
+ * list models provided by GTK.
+ *
+ * ## Performance Considerations
+ *
+ * Internally, the `GtkListStore` was originally implemented with a linked list
+ * with a tail pointer.  As a result, it was fast at data insertion and deletion,
+ * and not fast at random data access.  The `GtkListStore` sets the
+ * `GTK_TREE_MODEL_ITERS_PERSIST` flag, which means that `GtkTreeIter`s can be
+ * cached while the row exists.  Thus, if access to a particular row is needed
+ * often and your code is expected to run on older versions of GTK, it is worth
+ * keeping the iter around.
+ *
+ * ## Atomic Operations
+ *
+ * It is important to note that only the methods
+ * gtk_list_store_insert_with_values() and gtk_list_store_insert_with_valuesv()
+ * are atomic, in the sense that the row is being appended to the store and the
+ * values filled in in a single operation with regard to `GtkTreeModel` signaling.
+ * In contrast, using e.g. gtk_list_store_append() and then gtk_list_store_set()
+ * will first create a row, which triggers the `GtkTreeModel::row-inserted` signal
+ * on `GtkListStore`. The row, however, is still empty, and any signal handler
+ * connecting to `GtkTreeModel::row-inserted` on this particular store should be prepared
+ * for the situation that the row might be empty. This is especially important
+ * if you are wrapping the `GtkListStore` inside a `GtkTreeModel`Filter and are
+ * using a `GtkTreeModel`FilterVisibleFunc. Using any of the non-atomic operations
+ * to append rows to the `GtkListStore` will cause the
+ * `GtkTreeModel`FilterVisibleFunc to be visited with an empty row first; the
+ * function must be prepared for that.
+ *
+ * ## GtkListStore as GtkBuildable
+ *
+ * The GtkListStore implementation of the [iface@Gtk.Buildable] interface allows
+ * to specify the model columns with a `<columns>` element that may contain
+ * multiple `<column>` elements, each specifying one model column. The “type”
+ * attribute specifies the data type for the column.
+ *
+ * Additionally, it is possible to specify content for the list store
+ * in the UI definition, with the `<data>` element. It can contain multiple
+ * `<row>` elements, each specifying to content for one row of the list model.
+ * Inside a `<row>`, the `<col>` elements specify the content for individual cells.
+ *
+ * Note that it is probably more common to define your models in the code,
+ * and one might consider it a layering violation to specify the content of
+ * a list store in a UI definition, data, not presentation, and common wisdom
+ * is to separate the two, as far as possible.
+ *
+ * An example of a UI Definition fragment for a list store:
+ *
+ * ```xml
+ * <object class="GtkListStore">
+ * <columns>
+ * <column type="gchararray"/>
+ * <column type="gchararray"/>
+ * <column type="gint"/>
+ * </columns>
+ * <data>
+ * <row>
+ * <col id="0">John</col>
+ * <col id="1">Doe</col>
+ * <col id="2">25</col>
+ * </row>
+ * <row>
+ * <col id="0">Johan</col>
+ * <col id="1">Dahlin</col>
+ * <col id="2">50</col>
+ * </row>
+ * </data>
+ * </object>
+ * ```
+ */
 export declare class ListStore extends GObject.GObject {
+    /**
+     * Creates a new `GtkListStore`.
+     *
+     * This function is meant to be used by language bindings.
+     * @param nColumns - number of columns in the list store
+     * @param types - an array of `GType` types for the columns, from first to last
+     */
     constructor(nColumns: number, types: number[]);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Appends a new row to @list_store.  `iter` will be changed to point to this new
+     * row.  The row will be empty after this function is called.  To fill in
+     * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+     * @param iter - An unset `GtkTreeIter` to set to the appended row
+     */
     append(iter: Ref<TreeIter>): void;
+    /**
+     * Removes all rows from the list store.
+     */
     clear(): void;
+    /**
+     * Creates a new row at @position.  `iter` will be changed to point to this new
+     * row.  If `position` is -1 or is larger than the number of rows on the list,
+     * then the new row will be appended to the list. The row will be empty after
+     * this function is called.  To fill in values, you need to call
+     * gtk_list_store_set() or gtk_list_store_set_value().
+     * @param iter - An unset `GtkTreeIter` to set to the new row
+     * @param position - position to insert the new row, or -1 for last
+     */
     insert(iter: Ref<TreeIter>, position: number): void;
+    /**
+     * Inserts a new row after @sibling. If `sibling` is %NULL, then the row will be
+     * prepended to the beginning of the list. `iter` will be changed to point to
+     * this new row. The row will be empty after this function is called. To fill
+     * in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+     * @param iter - An unset `GtkTreeIter` to set to the new row
+     * @param sibling - A valid `GtkTreeIter`
+     */
     insertAfter(iter: Ref<TreeIter>, sibling?: TreeIter | null): void;
+    /**
+     * Inserts a new row before @sibling. If `sibling` is %NULL, then the row will
+     * be appended to the end of the list. `iter` will be changed to point to this
+     * new row. The row will be empty after this function is called. To fill in
+     * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+     * @param iter - An unset `GtkTreeIter` to set to the new row
+     * @param sibling - A valid `GtkTreeIter`
+     */
     insertBefore(iter: Ref<TreeIter>, sibling?: TreeIter | null): void;
+    /**
+     * A variant of gtk_list_store_insert_with_values() which
+     * takes the columns and values as two arrays, instead of
+     * varargs.
+     *
+     * This function is mainly intended for language-bindings.
+     * @param iter - An unset `GtkTreeIter` to set to the new row
+     * @param position - position to insert the new row, or -1 for last
+     * @param columns - an array of column numbers
+     * @param values - an array of GValues
+     * @param nValues - the length of the `columns` and `values` arrays
+     */
     insertWithValuesv(position: number, columns: number[], values: GObject.Value[], nValues: number, iter?: Ref<TreeIter> | null): void;
+    /**
+     * Checks if the given iter is a valid iter for this `GtkListStore`.
+     *
+     * This function is slow. Only use it for debugging and/or testing
+     * purposes.
+     * @param iter - the iterator to check
+     */
     iterIsValid(iter: TreeIter): boolean;
+    /**
+     * Moves `iter` in `store` to the position after @position. Note that this
+     * function only works with unsorted stores. If `position` is %NULL, `iter` will be moved to the start of the list.
+     * @param iter - A `GtkTreeIter`
+     * @param position - A `GtkTreeIter`
+     */
     moveAfter(iter: TreeIter, position?: TreeIter | null): void;
+    /**
+     * Moves `iter` in `store` to the position before @position. Note that this
+     * function only works with unsorted stores. If `position` is %NULL, `iter` will be moved to the end of the list.
+     * @param iter - A `GtkTreeIter`
+     * @param position - A `GtkTreeIter`
+     */
     moveBefore(iter: TreeIter, position?: TreeIter | null): void;
+    /**
+     * Prepends a new row to @list_store. `iter` will be changed to point to this new
+     * row. The row will be empty after this function is called. To fill in
+     * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+     * @param iter - An unset `GtkTreeIter` to set to the prepend row
+     */
     prepend(iter: Ref<TreeIter>): void;
+    /**
+     * Removes the given row from the list store.  After being removed,
+     * `iter` is set to be the next valid row, or invalidated if it pointed
+     * to the last row in @list_store.
+     * @param iter - A valid `GtkTreeIter`
+     */
     remove(iter: TreeIter): boolean;
+    /**
+     * Reorders `store` to follow the order indicated by @new_order. Note that
+     * this function only works with unsorted stores.
+     * @param newOrder - an array of integers mapping the new
+     */
     reorder(newOrder: number[]): void;
+    /**
+     * Sets the types of the columns of a list store.
+     *
+     * This function is meant primarily for objects that inherit
+     * from `GtkListStore`, and should only be used when constructing
+     * a new instance.
+     *
+     * This function cannot be called after a row has been added, or
+     * a method on the `GtkTreeModel` interface is called.
+     * @param nColumns - Number of columns for the list store
+     * @param types - An array length n of `GType`s
+     */
     setColumnTypes(nColumns: number, types: number[]): void;
+    /**
+     * Sets the data in the cell specified by `iter` and @column.
+     * The type of `value` must be convertible to the type of the
+     * column.
+     * @param iter - A valid `GtkTreeIter` for the row being modified
+     * @param column - column number to modify
+     * @param value - new value for the cell
+     */
     setValue(iter: TreeIter, column: number, value: GObject.Value): void;
+    /**
+     * A variant of gtk_list_store_set_valist() which
+     * takes the columns and values as two arrays, instead of
+     * varargs. This function is mainly intended for
+     * language-bindings and in case the number of columns to
+     * change is not known until run-time.
+     * @param iter - A valid `GtkTreeIter` for the row being modified
+     * @param columns - an array of column numbers
+     * @param values - an array of GValues
+     * @param nValues - the length of the `columns` and `values` arrays
+     */
     setValuesv(iter: TreeIter, columns: number[], values: GObject.Value[], nValues: number): void;
+    /**
+     * Swaps `a` and `b` in @store. Note that this function only works with
+     * unsorted stores.
+     * @param a - A `GtkTreeIter`
+     * @param b - Another `GtkTreeIter`
+     */
     swap(a: TreeIter, b: TreeIter): void;
+    /**
+     * Gets the ID of the `buildable` object.
+     *
+     * `GtkBuilder` sets the name based on the ID attribute
+     * of the `<object>` tag used to construct the @buildable.
+     */
     getBuildableId(): string | null;
+    /**
+     * Asks the `GtkTreeDragDest` to insert a row before the path @dest,
+     * deriving the contents of the row from @value. If `dest` is
+     * outside the tree so that inserting before it is impossible, %FALSE
+     * will be returned. Also, %FALSE may be returned if the new row is
+     * not created for some model-specific reason.  Should robustly handle
+     * a `dest` no longer found in the model!
+     * @param dest - row to drop in front of
+     * @param value - data to drop
+     */
     dragDataReceived(dest: TreePath, value: GObject.Value): boolean;
+    /**
+     * Determines whether a drop is possible before the given @dest_path,
+     * at the same depth as @dest_path. i.e., can we drop the data in
+     * `value` at that location. `dest_path` does not have to
+     * exist; the return value will almost certainly be %FALSE if the
+     * parent of `dest_path` doesn’t exist, though.
+     * @param destPath - destination row
+     * @param value - the data being dropped
+     */
     rowDropPossible(destPath: TreePath, value: GObject.Value): boolean;
+    /**
+     * Asks the `GtkTreeDragSource` to delete the row at @path, because
+     * it was moved somewhere else via drag-and-drop. Returns %FALSE
+     * if the deletion fails because `path` no longer exists, or for
+     * some model-specific reason. Should robustly handle a `path` no
+     * longer found in the model!
+     * @param path - row that was being dragged
+     */
     dragDataDelete(path: TreePath): boolean;
+    /**
+     * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+     * the row at @path. Should robustly handle a `path` no
+     * longer found in the model!
+     * @param path - row that was dragged
+     */
     dragDataGet(path: TreePath): Gdk.ContentProvider | null;
+    /**
+     * Asks the `GtkTreeDragSource` whether a particular row can be used as
+     * the source of a DND operation. If the source doesn’t implement
+     * this interface, the row is assumed draggable.
+     * @param path - row on which user is initiating a drag
+     */
     rowDraggable(path: TreePath): boolean;
+    /**
+     * Creates a new `GtkTreeModel`, with `child_model` as the child_model
+     * and `root` as the virtual root.
+     * @param root - A `GtkTreePath`
+     */
     filterNew(root?: TreePath | null): TreeModel;
+    /**
+     * Calls `func` on each node in model in a depth-first fashion.
+     *
+     * If `func` returns %TRUE, then the tree ceases to be walked,
+     * and gtk_tree_model_foreach() returns.
+     * @param func - a function to be called on each row
+     * @param userData - user data to passed to @func
+     */
     foreach(func: (...args: unknown[]) => unknown, userData?: number | null): void;
+    /**
+     * Returns the type of the column.
+     * @param index_ - the column index
+     */
     getColumnType(index_: number): number;
+    /**
+     * Returns a set of flags supported by this interface.
+     *
+     * The flags are a bitwise combination of `GtkTreeModel`Flags.
+     * The flags supported should not change during the lifetime
+     * of the @tree_model.
+     */
     getFlags(): TreeModelFlags;
+    /**
+     * Sets `iter` to a valid iterator pointing to @path.
+     *
+     * If `path` does not exist, `iter` is set to an invalid
+     * iterator and %FALSE is returned.
+     * @param iter - the uninitialized `GtkTreeIter`
+     * @param path - the `GtkTreePath`
+     */
     getIter(iter: Ref<TreeIter>, path: TreePath): boolean;
+    /**
+     * Initializes `iter` with the first iterator in the tree
+     * (the one at the path "0").
+     *
+     * Returns %FALSE if the tree is empty, %TRUE otherwise.
+     * @param iter - the uninitialized `GtkTreeIter`
+     */
     getIterFirst(iter: Ref<TreeIter>): boolean;
+    /**
+     * Sets `iter` to a valid iterator pointing to @path_string, if it
+     * exists.
+     *
+     * Otherwise, `iter` is left invalid and %FALSE is returned.
+     * @param iter - an uninitialized `GtkTreeIter`
+     * @param pathString - a string representation of a `GtkTreePath`
+     */
     getIterFromString(iter: Ref<TreeIter>, pathString: string): boolean;
+    /**
+     * Returns the number of columns supported by @tree_model.
+     */
     getNColumns(): number;
+    /**
+     * Returns a newly-created `GtkTreePath` referenced by @iter.
+     *
+     * This path should be freed with gtk_tree_path_free().
+     * @param iter - the `GtkTreeIter`
+     */
     getPath(iter: TreeIter): TreePath;
+    /**
+     * Generates a string representation of the iter.
+     *
+     * This string is a “:” separated list of numbers.
+     * For example, “4:10:0:3” would be an acceptable
+     * return value for this string.
+     * @param iter - a `GtkTreeIter`
+     */
     getStringFromIter(iter: TreeIter): string | null;
+    /**
+     * Initializes and sets `value` to that at @column.
+     *
+     * When done with @value, g_value_unset() needs to be called
+     * to free any allocated memory.
+     * @param iter - the `GtkTreeIter`
+     * @param column - the column to lookup the value at
+     * @param value - an empty `GValue` to set
+     */
     getValue(iter: TreeIter, column: number, value: Ref<GObject.Value>): void;
+    /**
+     * Sets `iter` to point to the first child of @parent.
+     *
+     * If `parent` has no children, %FALSE is returned and `iter` is
+     * set to be invalid. `parent` will remain a valid node after this
+     * function has been called.
+     *
+     * If `parent` is %NULL returns the first node, equivalent to
+     * `gtk_tree_model_get_iter_first (tree_model, iter);`
+     * @param iter - the new `GtkTreeIter` to be set to the child
+     * @param parent - the `GtkTreeIter`
+     */
     iterChildren(iter: Ref<TreeIter>, parent?: TreeIter | null): boolean;
+    /**
+     * Returns %TRUE if `iter` has children, %FALSE otherwise.
+     * @param iter - the `GtkTreeIter` to test for children
+     */
     iterHasChild(iter: TreeIter): boolean;
+    /**
+     * Returns the number of children that `iter` has.
+     *
+     * As a special case, if `iter` is %NULL, then the number
+     * of toplevel nodes is returned.
+     * @param iter - the `GtkTreeIter`
+     */
     iterNChildren(iter?: TreeIter | null): number;
+    /**
+     * Sets `iter` to point to the node following it at the current level.
+     *
+     * If there is no next @iter, %FALSE is returned and `iter` is set
+     * to be invalid.
+     * @param iter - the `GtkTreeIter`
+     */
     iterNext(iter: TreeIter): boolean;
+    /**
+     * Sets `iter` to be the child of @parent, using the given index.
+     *
+     * The first index is 0. If `n` is too big, or `parent` has no children,
+     * `iter` is set to an invalid iterator and %FALSE is returned. `parent` will remain a valid node after this function has been called. As a
+     * special case, if `parent` is %NULL, then the @n-th root node
+     * is set.
+     * @param iter - the `GtkTreeIter` to set to the nth child
+     * @param parent - the `GtkTreeIter` to get the child from
+     * @param n - the index of the desired child
+     */
     iterNthChild(iter: Ref<TreeIter>, n: number, parent?: TreeIter | null): boolean;
+    /**
+     * Sets `iter` to be the parent of @child.
+     *
+     * If `child` is at the toplevel, and doesn’t have a parent, then
+     * `iter` is set to an invalid iterator and %FALSE is returned.
+     * `child` will remain a valid node after this function has been
+     * called.
+     *
+     * `iter` will be initialized before the lookup is performed, so `child` and `iter` cannot point to the same memory location.
+     * @param iter - the new `GtkTreeIter` to set to the parent
+     * @param child - the `GtkTreeIter`
+     */
     iterParent(iter: Ref<TreeIter>, child: TreeIter): boolean;
+    /**
+     * Sets `iter` to point to the previous node at the current level.
+     *
+     * If there is no previous @iter, %FALSE is returned and `iter` is
+     * set to be invalid.
+     * @param iter - the `GtkTreeIter`
+     */
     iterPrevious(iter: TreeIter): boolean;
+    /**
+     * Lets the tree ref the node.
+     *
+     * This is an optional method for models to implement.
+     * To be more specific, models may ignore this call as it exists
+     * primarily for performance reasons.
+     *
+     * This function is primarily meant as a way for views to let
+     * caching models know when nodes are being displayed (and hence,
+     * whether or not to cache that node). Being displayed means a node
+     * is in an expanded branch, regardless of whether the node is currently
+     * visible in the viewport. For example, a file-system based model
+     * would not want to keep the entire file-hierarchy in memory,
+     * just the sections that are currently being displayed by
+     * every current view.
+     *
+     * A model should be expected to be able to get an iter independent
+     * of its reffed state.
+     * @param iter - the `GtkTreeIter`
+     */
     refNode(iter: TreeIter): void;
+    /**
+     * Emits the ::row-changed signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::row-changed].
+     * @param path - a `GtkTreePath` pointing to the changed row
+     * @param iter - a valid `GtkTreeIter` pointing to the changed row
+     */
     rowChanged(path: TreePath, iter: TreeIter): void;
+    /**
+     * Emits the ::row-deleted signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::row-deleted].
+     *
+     * This should be called by models after a row has been removed.
+     * The location pointed to by `path` should be the location that
+     * the row previously was at. It may not be a valid location anymore.
+     *
+     * Nodes that are deleted are not unreffed, this means that any
+     * outstanding references on the deleted node should not be released.
+     * @param path - a `GtkTreePath` pointing to the previous location of
+     */
     rowDeleted(path: TreePath): void;
+    /**
+     * Emits the ::row-has-child-toggled signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::row-has-child-toggled].
+     *
+     * This should be called by models after the child
+     * state of a node changes.
+     * @param path - a `GtkTreePath` pointing to the changed row
+     * @param iter - a valid `GtkTreeIter` pointing to the changed row
+     */
     rowHasChildToggled(path: TreePath, iter: TreeIter): void;
+    /**
+     * Emits the ::row-inserted signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::row-inserted].
+     * @param path - a `GtkTreePath` pointing to the inserted row
+     * @param iter - a valid `GtkTreeIter` pointing to the inserted row
+     */
     rowInserted(path: TreePath, iter: TreeIter): void;
+    /**
+     * Emits the ::rows-reordered signal on @tree_model.
+     *
+     * See [signal@Gtk.TreeModel::rows-reordered].
+     *
+     * This should be called by models when their rows have been
+     * reordered.
+     * @param path - a `GtkTreePath` pointing to the tree node whose children
+     * @param iter - a valid `GtkTreeIter` pointing to the node
+     * @param newOrder - an array of integers
+     * @param length - length of `new_order` array
+     */
     rowsReorderedWithLength(path: TreePath, newOrder: number[], length: number, iter?: TreeIter | null): void;
+    /**
+     * Lets the tree unref the node.
+     *
+     * This is an optional method for models to implement.
+     * To be more specific, models may ignore this call as it exists
+     * primarily for performance reasons. For more information on what
+     * this means, see gtk_tree_model_ref_node().
+     *
+     * Please note that nodes that are deleted are not unreffed.
+     * @param iter - the `GtkTreeIter`
+     */
     unrefNode(iter: TreeIter): void;
+    /**
+     * Fills in `sort_column_id` and `order` with the current sort column and the
+     * order. It returns %TRUE unless the `sort_column_id` is
+     * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+     * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+     * @param sortColumnId - The sort column id to be filled in
+     * @param order - The `GtkSortType` to be filled in
+     */
     getSortColumnId(sortColumnId: Ref<number>, order: Ref<SortType>): boolean;
+    /**
+     * Returns %TRUE if the model has a default sort function. This is used
+     * primarily by GtkTreeViewColumns in order to determine if a model can
+     * go back to the default state, or not.
+     */
     hasDefaultSortFunc(): boolean;
+    /**
+     * Sets the default comparison function used when sorting to be @sort_func.
+     * If the current sort column id of `sortable` is
+     * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+     * this function.
+     *
+     * If `sort_func` is %NULL, then there will be no default comparison function.
+     * This means that once the model  has been sorted, it can’t go back to the
+     * default state. In this case, when the current sort column id of `sortable` is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+     * @param sortFunc - The comparison function
+     * @param userData - User data to pass to @sort_func
+     * @param destroy - Destroy notifier of @user_data
+     */
     setDefaultSortFunc(sortFunc: (...args: unknown[]) => unknown, userData?: number | null, destroy?: () => void | null): void;
+    /**
+     * Sets the current sort column to be @sort_column_id. The `sortable` will
+     * resort itself to reflect this change, after emitting a
+     * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+     * a regular column id, or one of the following special values:
+     *
+     * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+     * will be used, if it is set
+     *
+     * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+     * @param sortColumnId - the sort column id to set
+     * @param order - The sort order of the column
+     */
     setSortColumnId(sortColumnId: number, order: SortType): void;
+    /**
+     * Sets the comparison function used when sorting to be @sort_func. If the
+     * current sort column id of `sortable` is the same as @sort_column_id, then
+     * the model will sort using this function.
+     * @param sortColumnId - the sort column id to set the function for
+     * @param sortFunc - The comparison function
+     * @param userData - User data to pass to @sort_func
+     * @param destroy - Destroy notifier of @user_data
+     */
     setSortFunc(sortColumnId: number, sortFunc: (...args: unknown[]) => unknown, userData?: number | null, destroy?: () => void | null): void;
+    /**
+     * Emits a `GtkTreeSortable::sort-column-changed` signal on @sortable.
+     */
     sortColumnChanged(): void;
     connect(signal: "notify", handler: (self: ListStore, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;