@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gtk/text-iter.d.ts

@@ -6,98 +6,862 @@ import { TextMark } from "./text-mark.js";
 import { TextTag } from "./text-tag.js";
 import * as Gdk from "../gdk/index.js";
 import * as Pango from "../pango/index.js";
+/**
+ * Iterates over the contents of a `GtkTextBuffer`.
+ *
+ * You may wish to begin by reading the
+ * text widget conceptual overview,
+ * which gives an overview of all the objects and data types
+ * related to the text widget and how they work together.
+ */
 export declare class TextIter {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /**
+     * Assigns the value of `other` to @iter.
+     *
+     * This function is not useful in applications, because
+     * iterators can be assigned with `GtkTextIter i = j;`.
+     *
+     * The function is used by language bindings.
+     * @param other - another `GtkTextIter`
+     */
     assign(other: TextIter): void;
+    /**
+     * Moves backward by one character offset.
+     *
+     * Returns %TRUE if movement was possible; if `iter` was the first
+     * in the buffer (character offset 0), this function returns %FALSE
+     * for convenience when writing loops.
+     */
     backwardChar(): boolean;
+    /**
+     * Moves `count` characters backward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves
+     * to the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE.
+     * @param count - number of characters to move
+     */
     backwardChars(count: number): boolean;
+    /**
+     * Like [method@Gtk.TextIter.forward_cursor_position], but moves backward.
+     */
     backwardCursorPosition(): boolean;
+    /**
+     * Moves up to `count` cursor positions.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] for details.
+     * @param count - number of positions to move
+     */
     backwardCursorPositions(count: number): boolean;
+    /**
+     * Same as [method@Gtk.TextIter.forward_find_char],
+     * but goes backward from @iter.
+     * @param pred - function to be called on each character
+     * @param userData - user data for @pred
+     * @param limit - search limit
+     */
     backwardFindChar(pred: (...args: unknown[]) => unknown, userData?: number | null, limit?: TextIter | null): boolean;
+    /**
+     * Moves `iter` to the start of the previous line.
+     *
+     * Returns %TRUE if `iter` could be moved; i.e. if `iter` was at
+     * character offset 0, this function returns %FALSE. Therefore,
+     * if `iter` was already on line 0, but not at the start of the line,
+     * `iter` is snapped to the start of the line and the function returns
+     * %TRUE. (Note that this implies that
+     * in a loop calling this function, the line number may not change on
+     * every iteration, if your first iteration is on line 0.)
+     */
     backwardLine(): boolean;
+    /**
+     * Moves `count` lines backward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves to
+     * the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE. If `count` is negative,
+     * moves forward by 0 - `count` lines.
+     * @param count - number of lines to move backward
+     */
     backwardLines(count: number): boolean;
+    /**
+     * Same as [method@Gtk.TextIter.forward_search], but moves backward.
+     *
+     * `match_end` will never be set to a `GtkTextIter` located after @iter,
+     * even if there is a possible `match_start` before or at @iter.
+     * @param str - search string
+     * @param flags - bitmask of flags affecting the search
+     * @param matchStart - return location for start of match
+     * @param matchEnd - return location for end of match
+     * @param limit - location of last possible @match_start, or %NULL for start of buffer
+     */
     backwardSearch(str: string, flags: TextSearchFlags, matchStart?: Ref<TextIter> | null, matchEnd?: Ref<TextIter> | null, limit?: TextIter | null): boolean;
+    /**
+     * Moves backward to the previous sentence start.
+     *
+     * If `iter` is already at the start of a sentence, moves backward
+     * to the next one.
+     *
+     * Sentence boundaries are determined by Pango and should
+     * be correct for nearly any language.
+     */
     backwardSentenceStart(): boolean;
+    /**
+     * Calls [method@Gtk.TextIter.backward_sentence_start] up to `count` times.
+     *
+     * If `count` is negative, moves forward instead of backward.
+     * @param count - number of sentences to move
+     */
     backwardSentenceStarts(count: number): boolean;
+    /**
+     * Moves backward to the next toggle (on or off) of the
+     * @tag, or to the next toggle of any tag if
+     * `tag` is %NULL.
+     *
+     * If no matching tag toggles are found,
+     * returns %FALSE, otherwise %TRUE. Does not return toggles
+     * located at @iter, only toggles before @iter. Sets `iter` to the location of the toggle, or the start of the buffer
+     * if no toggle is found.
+     * @param tag - a `GtkTextTag`
+     */
     backwardToTagToggle(tag?: TextTag | null): boolean;
+    /**
+     * Moves `iter` backward to the previous visible cursor position.
+     *
+     * See [method@Gtk.TextIter.backward_cursor_position] for details.
+     */
     backwardVisibleCursorPosition(): boolean;
+    /**
+     * Moves up to `count` visible cursor positions.
+     *
+     * See [method@Gtk.TextIter.backward_cursor_position] for details.
+     * @param count - number of positions to move
+     */
     backwardVisibleCursorPositions(count: number): boolean;
+    /**
+     * Moves `iter` to the start of the previous visible line.
+     *
+     * Returns %TRUE if
+     * `iter` could be moved; i.e. if `iter` was at character offset 0, this
+     * function returns %FALSE. Therefore if `iter` was already on line 0,
+     * but not at the start of the line, `iter` is snapped to the start of
+     * the line and the function returns %TRUE. (Note that this implies that
+     * in a loop calling this function, the line number may not change on
+     * every iteration, if your first iteration is on line 0.)
+     */
     backwardVisibleLine(): boolean;
+    /**
+     * Moves `count` visible lines backward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves to
+     * the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE. If `count` is negative,
+     * moves forward by 0 - `count` lines.
+     * @param count - number of lines to move backward
+     */
     backwardVisibleLines(count: number): boolean;
+    /**
+     * Moves backward to the previous visible word start.
+     *
+     * If `iter` is currently on a word start, moves backward to the
+     * next one after that.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     */
     backwardVisibleWordStart(): boolean;
+    /**
+     * Calls [method@Gtk.TextIter.backward_visible_word_start] up to `count` times.
+     * @param count - number of times to move
+     */
     backwardVisibleWordStarts(count: number): boolean;
+    /**
+     * Moves backward to the previous word start.
+     *
+     * If `iter` is currently on a word start, moves backward to the
+     * next one after that.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language
+     */
     backwardWordStart(): boolean;
+    /**
+     * Calls [method@Gtk.TextIter.backward_word_start] up to `count` times.
+     * @param count - number of times to move
+     */
     backwardWordStarts(count: number): boolean;
+    /**
+     * Considering the default editability of the buffer, and tags that
+     * affect editability, determines whether text inserted at `iter` would
+     * be editable.
+     *
+     * If text inserted at `iter` would be editable then the
+     * user should be allowed to insert text at @iter.
+     * [method@Gtk.TextBuffer.insert_interactive] uses this function
+     * to decide whether insertions are allowed at a given position.
+     * @param defaultEditability - %TRUE if text is editable by default
+     */
     canInsert(defaultEditability: boolean): boolean;
+    /**
+     * A qsort()-style function that returns negative if `lhs` is less than
+     * @rhs, positive if `lhs` is greater than @rhs, and 0 if they’re equal.
+     *
+     * Ordering is in character offset order, i.e. the first character
+     * in the buffer is less than the second character in the buffer.
+     * @param rhs - another `GtkTextIter`
+     */
     compare(rhs: TextIter): number;
+    /**
+     * Creates a dynamically-allocated copy of an iterator.
+     *
+     * This function is not useful in applications, because
+     * iterators can be copied with a simple assignment
+     * (`GtkTextIter i = j;`).
+     *
+     * The function is used by language bindings.
+     */
     copy(): TextIter;
+    /**
+     * Returns whether the character at `iter` is within an editable region
+     * of text.
+     *
+     * Non-editable text is “locked” and can’t be changed by the
+     * user via `GtkTextView`. If no tags applied to this text affect
+     * editability, `default_setting` will be returned.
+     *
+     * You don’t want to use this function to decide whether text can be
+     * inserted at @iter, because for insertion you don’t want to know
+     * whether the char at `iter` is inside an editable range, you want to
+     * know whether a new character inserted at `iter` would be inside an
+     * editable range. Use [method@Gtk.TextIter.can_insert] to handle this
+     * case.
+     * @param defaultSetting - %TRUE if text is editable by default
+     */
     editable(defaultSetting: boolean): boolean;
+    /**
+     * Returns %TRUE if `iter` points to the start of the paragraph
+     * delimiter characters for a line.
+     *
+     * Delimiters will be either a newline, a carriage return, a carriage
+     * return followed by a newline, or a Unicode paragraph separator
+     * character.
+     *
+     * Note that an iterator pointing to the \n of a \r\n pair will not be
+     * counted as the end of a line, the line ends before the \r. The end
+     * iterator is considered to be at the end of a line, even though there
+     * are no paragraph delimiter chars there.
+     */
     endsLine(): boolean;
+    /**
+     * Determines whether `iter` ends a sentence.
+     *
+     * Sentence boundaries are determined by Pango and should
+     * be correct for nearly any language.
+     */
     endsSentence(): boolean;
+    /**
+     * Returns %TRUE if `tag` is toggled off at exactly this point.
+     *
+     * If `tag` is %NULL, returns %TRUE if any tag is toggled off at this point.
+     *
+     * Note that if this function returns %TRUE, it means that
+     * `iter` is at the end of the tagged range, but that the character
+     * at `iter` is outside the tagged range. In other words,
+     * unlike [method@Gtk.TextIter.starts_tag], if this function
+     * returns %TRUE, [method@Gtk.TextIter.has_tag] will return
+     * %FALSE for the same parameters.
+     * @param tag - a `GtkTextTag`
+     */
     endsTag(tag?: TextTag | null): boolean;
+    /**
+     * Determines whether `iter` ends a natural-language word.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     */
     endsWord(): boolean;
+    /**
+     * Tests whether two iterators are equal, using the fastest possible
+     * mechanism.
+     *
+     * This function is very fast; you can expect it to perform
+     * better than e.g. getting the character offset for each
+     * iterator and comparing the offsets yourself. Also, it’s a
+     * bit faster than [method@Gtk.TextIter.compare].
+     * @param rhs - another `GtkTextIter`
+     */
     equal(rhs: TextIter): boolean;
+    /**
+     * Moves `iter` forward by one character offset.
+     *
+     * Note that images embedded in the buffer occupy 1 character slot, so
+     * this function may actually move onto an image instead of a character,
+     * if you have images in your buffer. If `iter` is the end iterator or
+     * one character before it, `iter` will now point at the end iterator,
+     * and this function returns %FALSE for convenience when writing loops.
+     */
     forwardChar(): boolean;
+    /**
+     * Moves `count` characters if possible.
+     *
+     * If `count` would move past the start or end of the buffer,
+     * moves to the start or end of the buffer.
+     *
+     * The return value indicates whether the new position of
+     * `iter` is different from its original position, and dereferenceable
+     * (the last iterator in the buffer is not dereferenceable). If `count` is 0, the function does nothing and returns %FALSE.
+     * @param count - number of characters to move, may be negative
+     */
     forwardChars(count: number): boolean;
+    /**
+     * Moves `iter` forward by a single cursor position.
+     *
+     * Cursor positions are (unsurprisingly) positions where the
+     * cursor can appear. Perhaps surprisingly, there may not be
+     * a cursor position between all characters. The most common
+     * example for European languages would be a carriage return/newline
+     * sequence.
+     *
+     * For some Unicode characters, the equivalent of say the letter “a”
+     * with an accent mark will be represented as two characters, first
+     * the letter then a "combining mark" that causes the accent to be
+     * rendered; so the cursor can’t go between those two characters.
+     *
+     * See also the [struct@Pango.LogAttr] struct and the [func@Pango.break]
+     * function.
+     */
     forwardCursorPosition(): boolean;
+    /**
+     * Moves up to `count` cursor positions.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] for details.
+     * @param count - number of positions to move
+     */
     forwardCursorPositions(count: number): boolean;
+    /**
+     * Advances @iter, calling `pred` on each character.
+     *
+     * If `pred` returns %TRUE, returns %TRUE and stops scanning.
+     * If `pred` never returns %TRUE, `iter` is set to `limit` if
+     * `limit` is non-%NULL, otherwise to the end iterator.
+     * @param pred - a function to be called on each character
+     * @param userData - user data for @pred
+     * @param limit - search limit
+     */
     forwardFindChar(pred: (...args: unknown[]) => unknown, userData?: number | null, limit?: TextIter | null): boolean;
+    /**
+     * Moves `iter` to the start of the next line.
+     *
+     * If the iter is already on the last line of the buffer,
+     * moves the iter to the end of the current line. If after
+     * the operation, the iter is at the end of the buffer and not
+     * dereferenceable, returns %FALSE. Otherwise, returns %TRUE.
+     */
     forwardLine(): boolean;
+    /**
+     * Moves `count` lines forward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves to
+     * the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE. If `count` is negative,
+     * moves backward by 0 - `count` lines.
+     * @param count - number of lines to move forward
+     */
     forwardLines(count: number): boolean;
+    /**
+     * Searches forward for @str.
+     *
+     * Any match is returned by setting `match_start` to the first character
+     * of the match and `match_end` to the first character after the match.
+     * The search will not continue past @limit. Note that a search is a
+     * linear or O(n) operation, so you may wish to use `limit` to avoid
+     * locking up your UI on large buffers.
+     *
+     * `match_start` will never be set to a `GtkTextIter` located before @iter,
+     * even if there is a possible `match_end` after or at @iter.
+     * @param str - a search string
+     * @param flags - flags affecting how the search is done
+     * @param matchStart - return location for start of match
+     * @param matchEnd - return location for end of match
+     * @param limit - location of last possible @match_end, or %NULL for the end of the buffer
+     */
     forwardSearch(str: string, flags: TextSearchFlags, matchStart?: Ref<TextIter> | null, matchEnd?: Ref<TextIter> | null, limit?: TextIter | null): boolean;
+    /**
+     * Moves forward to the next sentence end.
+     *
+     * If `iter` is at the end of a sentence, moves to the next
+     * end of sentence.
+     *
+     * Sentence boundaries are determined by Pango and should
+     * be correct for nearly any language.
+     */
     forwardSentenceEnd(): boolean;
+    /**
+     * Calls [method@Gtk.TextIter.forward_sentence_end] `count` times.
+     *
+     * If `count` is negative, moves backward instead of forward.
+     * @param count - number of sentences to move
+     */
     forwardSentenceEnds(count: number): boolean;
+    /**
+     * Moves `iter` forward to the “end iterator”, which points
+     * one past the last valid character in the buffer.
+     *
+     * [method@Gtk.TextIter.get_char] called on the end iterator
+     * returns 0, which is convenient for writing loops.
+     */
     forwardToEnd(): void;
+    /**
+     * Moves the iterator to point to the paragraph delimiter characters.
+     *
+     * The possible characters are either a newline, a carriage return,
+     * a carriage return/newline in sequence, or the Unicode paragraph
+     * separator character.
+     *
+     * If the iterator is already at the paragraph delimiter
+     * characters, moves to the paragraph delimiter characters for the
+     * next line. If `iter` is on the last line in the buffer, which does
+     * not end in paragraph delimiters, moves to the end iterator (end of
+     * the last line), and returns %FALSE.
+     */
     forwardToLineEnd(): boolean;
+    /**
+     * Moves forward to the next toggle (on or off) of the
+     * @tag, or to the next toggle of any tag if
+     * `tag` is %NULL.
+     *
+     * If no matching tag toggles are found,
+     * returns %FALSE, otherwise %TRUE. Does not return toggles
+     * located at @iter, only toggles after @iter. Sets `iter` to
+     * the location of the toggle, or to the end of the buffer
+     * if no toggle is found.
+     * @param tag - a `GtkTextTag`
+     */
     forwardToTagToggle(tag?: TextTag | null): boolean;
+    /**
+     * Moves `iter` forward to the next visible cursor position.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] for details.
+     */
     forwardVisibleCursorPosition(): boolean;
+    /**
+     * Moves up to `count` visible cursor positions.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] for details.
+     * @param count - number of positions to move
+     */
     forwardVisibleCursorPositions(count: number): boolean;
+    /**
+     * Moves `iter` to the start of the next visible line.
+     *
+     * Returns %TRUE if there
+     * was a next line to move to, and %FALSE if `iter` was simply moved to
+     * the end of the buffer and is now not dereferenceable, or if `iter` was
+     * already at the end of the buffer.
+     */
     forwardVisibleLine(): boolean;
+    /**
+     * Moves `count` visible lines forward, if possible.
+     *
+     * If `count` would move past the start or end of the buffer, moves to
+     * the start or end of the buffer.
+     *
+     * The return value indicates whether the iterator moved
+     * onto a dereferenceable position; if the iterator didn’t move, or
+     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+     * the function does nothing and returns %FALSE. If `count` is negative,
+     * moves backward by 0 - `count` lines.
+     * @param count - number of lines to move forward
+     */
     forwardVisibleLines(count: number): boolean;
+    /**
+     * Moves forward to the next visible word end.
+     *
+     * If `iter` is currently on a word end, moves forward to the
+     * next one after that.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language
+     */
     forwardVisibleWordEnd(): boolean;
+    /**
+     * Calls [method@Gtk.TextIter.forward_visible_word_end] up to `count` times.
+     * @param count - number of times to move
+     */
     forwardVisibleWordEnds(count: number): boolean;
+    /**
+     * Moves forward to the next word end.
+     *
+     * If `iter` is currently on a word end, moves forward to the
+     * next one after that.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     */
     forwardWordEnd(): boolean;
+    /**
+     * Calls [method@Gtk.TextIter.forward_word_end] up to `count` times.
+     * @param count - number of times to move
+     */
     forwardWordEnds(count: number): boolean;
+    /**
+     * Free an iterator allocated on the heap.
+     *
+     * This function is intended for use in language bindings,
+     * and is not especially useful for applications, because
+     * iterators can simply be allocated on the stack.
+     */
     free(): void;
+    /**
+     * Returns the `GtkTextBuffer` this iterator is associated with.
+     */
     getBuffer(): TextBuffer;
+    /**
+     * Returns the number of bytes in the line containing @iter,
+     * including the paragraph delimiters.
+     */
     getBytesInLine(): number;
+    /**
+     * The Unicode character at this iterator is returned.
+     *
+     * Equivalent to operator* on a C++ iterator. If the element at
+     * this iterator is a non-character element, such as an image
+     * embedded in the buffer, the Unicode “unknown” character 0xFFFC
+     * is returned. If invoked on the end iterator, zero is returned;
+     * zero is not a valid Unicode character.
+     *
+     * So you can write a loop which ends when this function returns 0.
+     */
     getChar(): number;
+    /**
+     * Returns the number of characters in the line containing @iter,
+     * including the paragraph delimiters.
+     */
     getCharsInLine(): number;
+    /**
+     * If the location at `iter` contains a child anchor, the
+     * anchor is returned.
+     *
+     * Otherwise, %NULL is returned.
+     */
     getChildAnchor(): TextChildAnchor | null;
+    /**
+     * Returns the language in effect at @iter.
+     *
+     * If no tags affecting language apply to @iter, the return
+     * value is identical to that of [func@Gtk.get_default_language].
+     */
     getLanguage(): Pango.Language;
+    /**
+     * Returns the line number containing the iterator.
+     *
+     * Lines in a `GtkTextBuffer` are numbered beginning
+     * with 0 for the first line in the buffer.
+     */
     getLine(): number;
+    /**
+     * Returns the byte index of the iterator, counting
+     * from the start of a newline-terminated line.
+     *
+     * Remember that `GtkTextBuffer` encodes text in
+     * UTF-8, and that characters can require a variable
+     * number of bytes to represent.
+     */
     getLineIndex(): number;
+    /**
+     * Returns the character offset of the iterator,
+     * counting from the start of a newline-terminated line.
+     *
+     * The first character on the line has offset 0.
+     */
     getLineOffset(): number;
+    /**
+     * Returns a list of all `GtkTextMark` at this location.
+     *
+     * Because marks are not iterable (they don’t take up any "space"
+     * in the buffer, they are just marks in between iterable locations),
+     * multiple marks can exist in the same place.
+     *
+     * The returned list is not in any meaningful order.
+     */
     getMarks(): TextMark[];
+    /**
+     * Returns the character offset of an iterator.
+     *
+     * Each character in a `GtkTextBuffer` has an offset,
+     * starting with 0 for the first character in the buffer.
+     * Use [method@Gtk.TextBuffer.get_iter_at_offset] to convert
+     * an offset back into an iterator.
+     */
     getOffset(): number;
+    /**
+     * If the element at `iter` is a paintable, the paintable is returned.
+     *
+     * Otherwise, %NULL is returned.
+     */
     getPaintable(): Gdk.Paintable | null;
+    /**
+     * Returns the text in the given range.
+     *
+     * A “slice” is an array of characters encoded in UTF-8 format,
+     * including the Unicode “unknown” character 0xFFFC for iterable
+     * non-character elements in the buffer, such as images.
+     * Because images are encoded in the slice, byte and
+     * character offsets in the returned array will correspond to byte
+     * offsets in the text buffer. Note that 0xFFFC can occur in normal
+     * text as well, so it is not a reliable indicator that a paintable or
+     * widget is in the buffer.
+     * @param end - iterator at end of a range
+     */
     getSlice(end: TextIter): string;
+    /**
+     * Returns a list of tags that apply to @iter, in ascending order of
+     * priority.
+     *
+     * The highest-priority tags are last.
+     *
+     * The `GtkTextTag`s in the list don’t have a reference added,
+     * but you have to free the list itself.
+     */
     getTags(): TextTag[];
+    /**
+     * Returns text in the given range.
+     *
+     * If the range
+     * contains non-text elements such as images, the character and byte
+     * offsets in the returned string will not correspond to character and
+     * byte offsets in the buffer. If you want offsets to correspond, see
+     * [method@Gtk.TextIter.get_slice].
+     * @param end - iterator at end of a range
+     */
     getText(end: TextIter): string;
+    /**
+     * Returns a list of `GtkTextTag` that are toggled on or off at this
+     * point.
+     *
+     * If `toggled_on` is %TRUE, the list contains tags that are
+     * toggled on. If a tag is toggled on at @iter, then some non-empty
+     * range of characters following `iter` has that tag applied to it.  If
+     * a tag is toggled off, then some non-empty range following `iter` does not have the tag applied to it.
+     * @param toggledOn - %TRUE to get toggled-on tags
+     */
     getToggledTags(toggledOn: boolean): TextTag[];
+    /**
+     * Returns the number of bytes from the start of the
+     * line to the given @iter, not counting bytes that
+     * are invisible due to tags with the “invisible” flag
+     * toggled on.
+     */
     getVisibleLineIndex(): number;
+    /**
+     * Returns the offset in characters from the start of the
+     * line to the given @iter, not counting characters that
+     * are invisible due to tags with the “invisible” flag
+     * toggled on.
+     */
     getVisibleLineOffset(): number;
+    /**
+     * Returns visible text in the given range.
+     *
+     * Like [method@Gtk.TextIter.get_slice], but invisible text
+     * is not included. Invisible text is usually invisible because
+     * a `GtkTextTag` with the “invisible” attribute turned on has
+     * been applied to it.
+     * @param end - iterator at end of range
+     */
     getVisibleSlice(end: TextIter): string;
+    /**
+     * Returns visible text in the given range.
+     *
+     * Like [method@Gtk.TextIter.get_text], but invisible text
+     * is not included. Invisible text is usually invisible because
+     * a `GtkTextTag` with the “invisible” attribute turned on has
+     * been applied to it.
+     * @param end - iterator at end of range
+     */
     getVisibleText(end: TextIter): string;
+    /**
+     * Returns %TRUE if `iter` points to a character that is part
+     * of a range tagged with @tag.
+     *
+     * See also [method@Gtk.TextIter.starts_tag] and
+     * [method@Gtk.TextIter.ends_tag].
+     * @param tag - a `GtkTextTag`
+     */
     hasTag(tag: TextTag): boolean;
+    /**
+     * Checks whether `iter` falls in the range [@start, @end).
+     *
+     * `start` and `end` must be in ascending order.
+     * @param start - start of range
+     * @param end - end of range
+     */
     inRange(start: TextIter, end: TextIter): boolean;
+    /**
+     * Determines whether `iter` is inside a sentence (as opposed to in
+     * between two sentences, e.g. after a period and before the first
+     * letter of the next sentence).
+     *
+     * Sentence boundaries are determined by Pango and should be correct
+     * for nearly any language.
+     */
     insideSentence(): boolean;
+    /**
+     * Determines whether the character pointed by `iter` is part of a
+     * natural-language word (as opposed to say inside some whitespace).
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     *
+     * Note that if [method@Gtk.TextIter.starts_word] returns %TRUE,
+     * then this function returns %TRUE too, since `iter` points to
+     * the first character of the word.
+     */
     insideWord(): boolean;
+    /**
+     * Determine if `iter` is at a cursor position.
+     *
+     * See [method@Gtk.TextIter.forward_cursor_position] or
+     * [struct@Pango.LogAttr] or [func@Pango.break] for details
+     * on what a cursor position is.
+     */
     isCursorPosition(): boolean;
+    /**
+     * Returns %TRUE if `iter` is the end iterator.
+     *
+     * This means it is one past the last dereferenceable iterator
+     * in the buffer. [method@Gtk.TextIter.is_end] is the most efficient
+     * way to check whether an iterator is the end iterator.
+     */
     isEnd(): boolean;
+    /**
+     * Returns %TRUE if `iter` is the first iterator in the buffer.
+     */
     isStart(): boolean;
+    /**
+     * Swaps the value of `first` and `second` if `second` comes before
+     * `first` in the buffer.
+     *
+     * That is, ensures that `first` and `second` are in sequence.
+     * Most text buffer functions that take a range call this
+     * automatically on your behalf, so there’s no real reason to
+     * call it yourself in those cases. There are some exceptions,
+     * such as [method@Gtk.TextIter.in_range], that expect a
+     * pre-sorted range.
+     * @param second - another `GtkTextIter`
+     */
     order(second: TextIter): void;
+    /**
+     * Moves iterator `iter` to the start of the line @line_number.
+     *
+     * If `line_number` is negative or larger than or equal to the number of lines
+     * in the buffer, moves `iter` to the start of the last line in the buffer.
+     * @param lineNumber - line number (counted from 0)
+     */
     setLine(lineNumber: number): void;
+    /**
+     * Same as [method@Gtk.TextIter.set_line_offset], but works with a
+     * byte index. The given byte index must be at
+     * the start of a character, it can’t be in the middle of a UTF-8
+     * encoded character.
+     * @param byteOnLine - a byte index relative to the start of @iter’s current line
+     */
     setLineIndex(byteOnLine: number): void;
+    /**
+     * Moves `iter` within a line, to a new character (not byte) offset.
+     *
+     * The given character offset must be less than or equal to the number
+     * of characters in the line; if equal, `iter` moves to the start of the
+     * next line. See [method@Gtk.TextIter.set_line_index] if you have a byte
+     * index rather than a character offset.
+     * @param charOnLine - a character offset relative to the start of @iter’s current line
+     */
     setLineOffset(charOnLine: number): void;
+    /**
+     * Sets `iter` to point to @char_offset.
+     *
+     * `char_offset` counts from the start
+     * of the entire text buffer, starting with 0.
+     * @param charOffset - a character number
+     */
     setOffset(charOffset: number): void;
+    /**
+     * Like [method@Gtk.TextIter.set_line_index], but the index is in visible
+     * bytes, i.e. text with a tag making it invisible is not counted
+     * in the index.
+     * @param byteOnLine - a byte index
+     */
     setVisibleLineIndex(byteOnLine: number): void;
+    /**
+     * Like [method@Gtk.TextIter.set_line_offset], but the offset is in visible
+     * characters, i.e. text with a tag making it invisible is not
+     * counted in the offset.
+     * @param charOnLine - a character offset
+     */
     setVisibleLineOffset(charOnLine: number): void;
+    /**
+     * Returns %TRUE if `iter` begins a paragraph.
+     *
+     * This is the case if [method@Gtk.TextIter.get_line_offset]
+     * would return 0. However this function is potentially more
+     * efficient than [method@Gtk.TextIter.get_line_offset], because
+     * it doesn’t have to compute the offset, it just has to see
+     * whether it’s 0.
+     */
     startsLine(): boolean;
+    /**
+     * Determines whether `iter` begins a sentence.
+     *
+     * Sentence boundaries are determined by Pango and
+     * should be correct for nearly any language.
+     */
     startsSentence(): boolean;
+    /**
+     * Returns %TRUE if `tag` is toggled on at exactly this point.
+     *
+     * If `tag` is %NULL, returns %TRUE if any tag is toggled on at this point.
+     *
+     * Note that if this function returns %TRUE, it means that
+     * `iter` is at the beginning of the tagged range, and that the
+     * character at `iter` is inside the tagged range. In other
+     * words, unlike [method@Gtk.TextIter.ends_tag], if
+     * this function returns %TRUE, [method@Gtk.TextIter.has_tag]
+     * will also return %TRUE for the same parameters.
+     * @param tag - a `GtkTextTag`
+     */
     startsTag(tag?: TextTag | null): boolean;
+    /**
+     * Determines whether `iter` begins a natural-language word.
+     *
+     * Word breaks are determined by Pango and should be correct
+     * for nearly any language.
+     */
     startsWord(): boolean;
+    /**
+     * Gets whether a range with `tag` applied to it begins
+     * or ends at @iter.
+     *
+     * This is equivalent to (gtk_text_iter_starts_tag() ||
+     * gtk_text_iter_ends_tag())
+     * @param tag - a `GtkTextTag`
+     */
     togglesTag(tag?: TextTag | null): boolean;
 }