@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -8,77 +8,770 @@ import { TextTag } from "./text-tag.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 export declare class TextBuffer extends GObject.GObject {
+    /**
+     * Creates a new text buffer.
+     * @param table - a tag table, or %NULL to create a new one
+     */
     constructor(table?: TextTagTable | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Adds a [callback@Gtk.TextBufferCommitNotify] to be called when a change
+     * is to be made to the [type@Gtk.TextBuffer].
+     *
+     * Functions are explicitly forbidden from making changes to the
+     * [type@Gtk.TextBuffer] from this callback. It is intended for tracking
+     * changes to the buffer only.
+     *
+     * It may be advantageous to use [callback@Gtk.TextBufferCommitNotify] over
+     * connecting to the [signal@Gtk.TextBuffer::insert-text] or
+     * [signal@Gtk.TextBuffer::delete-range] signals to avoid ordering issues with
+     * other signal handlers which may further modify the [type@Gtk.TextBuffer].
+     * @param flags - which notifications should be dispatched to @callback
+     * @param commitNotify - a
+     * @param userData - closure data for @commit_notify
+     * @param destroy - a callback to free `user_data` when `commit_notify` is removed
+     */
     addCommitNotify(flags: TextBufferNotifyFlags, commitNotify: (...args: unknown[]) => unknown, destroy: () => void, userData?: number | null): number;
+    /**
+     * Adds the mark at position @where.
+     *
+     * The mark must not be added to another buffer, and if its name
+     * is not %NULL then there must not be another mark in the buffer
+     * with the same name.
+     *
+     * Emits the [signal@Gtk.TextBuffer::mark-set] signal as notification
+     * of the mark's initial placement.
+     * @param mark - the mark to add
+     * @param where - location to place mark
+     */
     addMark(mark: TextMark, where: TextIter): void;
+    /**
+     * Adds `clipboard` to the list of clipboards in which the selection
+     * contents of `buffer` are available.
+     *
+     * In most cases, `clipboard` will be the `GdkClipboard` returned by
+     * [method@Gtk.Widget.get_primary_clipboard] for a view of @buffer.
+     * @param clipboard - a `GdkClipboard`
+     */
     addSelectionClipboard(clipboard: Gdk.Clipboard): void;
+    /**
+     * Emits the “apply-tag” signal on @buffer.
+     *
+     * The default handler for the signal applies
+     * `tag` to the given range. `start` and `end` do
+     * not have to be in order.
+     * @param tag - a `GtkTextTag`
+     * @param start - one bound of range to be tagged
+     * @param end - other bound of range to be tagged
+     */
     applyTag(tag: TextTag, start: TextIter, end: TextIter): void;
+    /**
+     * Emits the “apply-tag” signal on @buffer.
+     *
+     * Calls [method@Gtk.TextTagTable.lookup] on the buffer’s
+     * tag table to get a `GtkTextTag`, then calls
+     * [method@Gtk.TextBuffer.apply_tag].
+     * @param name - name of a named `GtkTextTag`
+     * @param start - one bound of range to be tagged
+     * @param end - other bound of range to be tagged
+     */
     applyTagByName(name: string, start: TextIter, end: TextIter): void;
+    /**
+     * Performs the appropriate action as if the user hit the delete
+     * key with the cursor at the position specified by @iter.
+     *
+     * In the normal case a single character will be deleted, but when
+     * combining accents are involved, more than one character can
+     * be deleted, and when precomposed character and accent combinations
+     * are involved, less than one character will be deleted.
+     *
+     * Because the buffer is modified, all outstanding iterators become
+     * invalid after calling this function; however, the `iter` will be
+     * re-initialized to point to the location where text was deleted.
+     * @param iter - a position in @buffer
+     * @param interactive - whether the deletion is caused by user interaction
+     * @param defaultEditable - whether the buffer is editable by default
+     */
     backspace(iter: TextIter, interactive: boolean, defaultEditable: boolean): boolean;
+    /**
+     * Denotes the beginning of an action that may not be undone.
+     *
+     * This will cause any previous operations in the undo/redo queue
+     * to be cleared.
+     *
+     * This should be paired with a call to
+     * [method@Gtk.TextBuffer.end_irreversible_action] after the irreversible
+     * action has completed.
+     *
+     * You may nest calls to gtk_text_buffer_begin_irreversible_action()
+     * and gtk_text_buffer_end_irreversible_action() pairs.
+     */
     beginIrreversibleAction(): void;
+    /**
+     * Called to indicate that the buffer operations between here and a
+     * call to gtk_text_buffer_end_user_action() are part of a single
+     * user-visible operation.
+     *
+     * The operations between gtk_text_buffer_begin_user_action() and
+     * gtk_text_buffer_end_user_action() can then be grouped when creating
+     * an undo stack. `GtkTextBuffer` maintains a count of calls to
+     * gtk_text_buffer_begin_user_action() that have not been closed with
+     * a call to gtk_text_buffer_end_user_action(), and emits the
+     * “begin-user-action” and “end-user-action” signals only for the
+     * outermost pair of calls. This allows you to build user actions
+     * from other user actions.
+     *
+     * The “interactive” buffer mutation functions, such as
+     * [method@Gtk.TextBuffer.insert_interactive], automatically call
+     * begin/end user action around the buffer operations they perform,
+     * so there's no need to add extra calls if you user action consists
+     * solely of a single call to one of those functions.
+     */
     beginUserAction(): void;
+    /**
+     * Copies the currently-selected text to a clipboard.
+     * @param clipboard - the `GdkClipboard` object to copy to
+     */
     copyClipboard(clipboard: Gdk.Clipboard): void;
+    /**
+     * Creates and inserts a child anchor.
+     *
+     * This is a convenience function which simply creates a child anchor
+     * with [ctor@Gtk.TextChildAnchor.new] and inserts it into the buffer
+     * with [method@Gtk.TextBuffer.insert_child_anchor].
+     *
+     * The new anchor is owned by the buffer; no reference count is
+     * returned to the caller of this function.
+     * @param iter - location in the buffer
+     */
     createChildAnchor(iter: TextIter): TextChildAnchor;
+    /**
+     * Creates a mark at position @where.
+     *
+     * If `mark_name` is %NULL, the mark is anonymous; otherwise, the mark
+     * can be retrieved by name using [method@Gtk.TextBuffer.get_mark].
+     * If a mark has left gravity, and text is inserted at the mark’s
+     * current location, the mark will be moved to the left of the
+     * newly-inserted text. If the mark has right gravity
+     * (`left_gravity` = %FALSE), the mark will end up on the right of
+     * newly-inserted text. The standard left-to-right cursor is a mark
+     * with right gravity (when you type, the cursor stays on the right
+     * side of the text you’re typing).
+     *
+     * The caller of this function does not own a
+     * reference to the returned `GtkTextMark`, so you can ignore the
+     * return value if you like. Marks are owned by the buffer and go
+     * away when the buffer does.
+     *
+     * Emits the [signal@Gtk.TextBuffer::mark-set] signal as notification
+     * of the mark's initial placement.
+     * @param markName - name for mark
+     * @param where - location to place mark
+     * @param leftGravity - whether the mark has left gravity
+     */
     createMark(where: TextIter, leftGravity: boolean, markName?: string | null): TextMark;
+    /**
+     * Copies the currently-selected text to a clipboard,
+     * then deletes said text if it’s editable.
+     * @param clipboard - the `GdkClipboard` object to cut to
+     * @param defaultEditable - default editability of the buffer
+     */
     cutClipboard(clipboard: Gdk.Clipboard, defaultEditable: boolean): void;
+    /**
+     * Deletes text between `start` and @end.
+     *
+     * The order of `start` and `end` is not actually relevant;
+     * gtk_text_buffer_delete() will reorder them.
+     *
+     * This function actually emits the “delete-range” signal, and
+     * the default handler of that signal deletes the text. Because the
+     * buffer is modified, all outstanding iterators become invalid after
+     * calling this function; however, the `start` and `end` will be
+     * re-initialized to point to the location where text was deleted.
+     * @param start - a position in @buffer
+     * @param end - another position in @buffer
+     */
     delete(start: TextIter, end: TextIter): void;
+    /**
+     * Deletes all editable text in the given range.
+     *
+     * Calls [method@Gtk.TextBuffer.delete] for each editable
+     * sub-range of [@start,@end). `start` and `end` are revalidated
+     * to point to the location of the last deleted range, or left
+     * untouched if no text was deleted.
+     * @param startIter - start of range to delete
+     * @param endIter - end of range
+     * @param defaultEditable - whether the buffer is editable by default
+     */
     deleteInteractive(startIter: TextIter, endIter: TextIter, defaultEditable: boolean): boolean;
+    /**
+     * Deletes @mark, so that it’s no longer located anywhere in the
+     * buffer.
+     *
+     * Removes the reference the buffer holds to the mark, so if
+     * you haven’t called g_object_ref() on the mark, it will be freed.
+     * Even if the mark isn’t freed, most operations on `mark` become
+     * invalid, until it gets added to a buffer again with
+     * [method@Gtk.TextBuffer.add_mark]. Use [method@Gtk.TextMark.get_deleted]
+     * to find out if a mark has been removed from its buffer.
+     *
+     * The [signal@Gtk.TextBuffer::mark-deleted] signal will be emitted as
+     * notification after the mark is deleted.
+     * @param mark - a `GtkTextMark` in @buffer
+     */
     deleteMark(mark: TextMark): void;
+    /**
+     * Deletes the mark named @name; the mark must exist.
+     *
+     * See [method@Gtk.TextBuffer.delete_mark] for details.
+     * @param name - name of a mark in @buffer
+     */
     deleteMarkByName(name: string): void;
+    /**
+     * Deletes the range between the “insert” and “selection_bound” marks,
+     * that is, the currently-selected text.
+     *
+     * If `interactive` is %TRUE, the editability of the selection will be
+     * considered (users can’t delete uneditable text).
+     * @param interactive - whether the deletion is caused by user interaction
+     * @param defaultEditable - whether the buffer is editable by default
+     */
     deleteSelection(interactive: boolean, defaultEditable: boolean): boolean;
+    /**
+     * Denotes the end of an action that may not be undone.
+     *
+     * This will cause any previous operations in the undo/redo
+     * queue to be cleared.
+     *
+     * This should be called after completing modifications to the
+     * text buffer after [method@Gtk.TextBuffer.begin_irreversible_action]
+     * was called.
+     *
+     * You may nest calls to gtk_text_buffer_begin_irreversible_action()
+     * and gtk_text_buffer_end_irreversible_action() pairs.
+     */
     endIrreversibleAction(): void;
+    /**
+     * Ends a user-visible operation.
+     *
+     * Should be paired with a call to
+     * [method@Gtk.TextBuffer.begin_user_action].
+     * See that function for a full explanation.
+     */
     endUserAction(): void;
+    /**
+     * Retrieves the first and last iterators in the buffer, i.e. the
+     * entire buffer lies within the range [@start,@end).
+     * @param start - iterator to initialize with first position in the buffer
+     * @param end - iterator to initialize with the end iterator
+     */
     getBounds(start: Ref<TextIter>, end: Ref<TextIter>): void;
+    /**
+     * Gets whether there is a redoable action in the history.
+     */
     getCanRedo(): boolean;
+    /**
+     * Gets whether there is an undoable action in the history.
+     */
     getCanUndo(): boolean;
+    /**
+     * Gets the number of characters in the buffer.
+     *
+     * Note that characters and bytes are not the same, you can’t e.g.
+     * expect the contents of the buffer in string form to be this
+     * many bytes long.
+     *
+     * The character count is cached, so this function is very fast.
+     */
     getCharCount(): number;
+    /**
+     * Gets whether the buffer is saving modifications to the buffer
+     * to allow for undo and redo actions.
+     *
+     * See [method@Gtk.TextBuffer.begin_irreversible_action] and
+     * [method@Gtk.TextBuffer.end_irreversible_action] to create
+     * changes to the buffer that cannot be undone.
+     */
     getEnableUndo(): boolean;
+    /**
+     * Initializes `iter` with the “end iterator,” one past the last valid
+     * character in the text buffer.
+     *
+     * If dereferenced with [method@Gtk.TextIter.get_char], the end
+     * iterator has a character value of 0.
+     * The entire buffer lies in the range from the first position in
+     * the buffer (call [method@Gtk.TextBuffer.get_start_iter] to get
+     * character position 0) to the end iterator.
+     * @param iter - iterator to initialize
+     */
     getEndIter(iter: Ref<TextIter>): void;
+    /**
+     * Indicates whether the buffer has some text currently selected.
+     */
     getHasSelection(): boolean;
+    /**
+     * Returns the mark that represents the cursor (insertion point).
+     *
+     * Equivalent to calling [method@Gtk.TextBuffer.get_mark]
+     * to get the mark named “insert”, but very slightly more
+     * efficient, and involves less typing.
+     */
     getInsert(): TextMark;
+    /**
+     * Obtains the location of `anchor` within @buffer.
+     * @param iter - an iterator to be initialized
+     * @param anchor - a child anchor that appears in @buffer
+     */
     getIterAtChildAnchor(iter: Ref<TextIter>, anchor: TextChildAnchor): void;
+    /**
+     * Initializes `iter` to the start of the given line.
+     *
+     * If `line_number` is greater than or equal to the number of lines
+     * in the @buffer, the end iterator is returned.
+     * @param iter - iterator to initialize
+     * @param lineNumber - line number counting from 0
+     */
     getIterAtLine(iter: Ref<TextIter>, lineNumber: number): boolean;
+    /**
+     * Obtains an iterator pointing to `byte_index` within the given line.
+     *
+     * `byte_index` must be the start of a UTF-8 character. Note bytes, not
+     * characters; UTF-8 may encode one character as multiple bytes.
+     *
+     * If `line_number` is greater than or equal to the number of lines in the @buffer,
+     * the end iterator is returned. And if `byte_index` is off the
+     * end of the line, the iterator at the end of the line is returned.
+     * @param iter - iterator to initialize
+     * @param lineNumber - line number counting from 0
+     * @param byteIndex - byte index from start of line
+     */
     getIterAtLineIndex(iter: Ref<TextIter>, lineNumber: number, byteIndex: number): boolean;
+    /**
+     * Obtains an iterator pointing to `char_offset` within the given line.
+     *
+     * Note characters, not bytes; UTF-8 may encode one character as multiple
+     * bytes.
+     *
+     * If `line_number` is greater than or equal to the number of lines in the @buffer,
+     * the end iterator is returned. And if `char_offset` is off the
+     * end of the line, the iterator at the end of the line is returned.
+     * @param iter - iterator to initialize
+     * @param lineNumber - line number counting from 0
+     * @param charOffset - char offset from start of line
+     */
     getIterAtLineOffset(iter: Ref<TextIter>, lineNumber: number, charOffset: number): boolean;
+    /**
+     * Initializes `iter` with the current position of @mark.
+     * @param iter - iterator to initialize
+     * @param mark - a `GtkTextMark` in @buffer
+     */
     getIterAtMark(iter: Ref<TextIter>, mark: TextMark): void;
+    /**
+     * Initializes `iter` to a position `char_offset` chars from the start
+     * of the entire buffer.
+     *
+     * If `char_offset` is -1 or greater than the number
+     * of characters in the buffer, `iter` is initialized to the end iterator,
+     * the iterator one past the last valid character in the buffer.
+     * @param iter - iterator to initialize
+     * @param charOffset - char offset from start of buffer, counting from 0, or -1
+     */
     getIterAtOffset(iter: Ref<TextIter>, charOffset: number): void;
+    /**
+     * Obtains the number of lines in the buffer.
+     *
+     * This value is cached, so the function is very fast.
+     */
     getLineCount(): number;
+    /**
+     * Returns the mark named `name` in buffer @buffer, or %NULL if no such
+     * mark exists in the buffer.
+     * @param name - a mark name
+     */
     getMark(name: string): TextMark | null;
+    /**
+     * Gets the maximum number of undo levels to perform.
+     *
+     * If 0, unlimited undo actions may be performed. Note that this may
+     * have a memory usage impact as it requires storing an additional
+     * copy of the inserted or removed text within the text buffer.
+     */
     getMaxUndoLevels(): number;
+    /**
+     * Indicates whether the buffer has been modified since the last call
+     * to [method@Gtk.TextBuffer.set_modified] set the modification flag to
+     * %FALSE.
+     *
+     * Used for example to enable a “save” function in a text editor.
+     */
     getModified(): boolean;
+    /**
+     * Returns the mark that represents the selection bound.
+     *
+     * Equivalent to calling [method@Gtk.TextBuffer.get_mark]
+     * to get the mark named “selection_bound”, but very slightly
+     * more efficient, and involves less typing.
+     *
+     * The currently-selected text in `buffer` is the region between the
+     * “selection_bound” and “insert” marks. If “selection_bound” and
+     * “insert” are in the same place, then there is no current selection.
+     * [method@Gtk.TextBuffer.get_selection_bounds] is another convenient
+     * function for handling the selection, if you just want to know whether
+     * there’s a selection and what its bounds are.
+     */
     getSelectionBound(): TextMark;
+    /**
+     * Returns %TRUE if some text is selected; places the bounds
+     * of the selection in `start` and @end.
+     *
+     * If the selection has length 0, then `start` and `end` are filled
+     * in with the same value. `start` and `end` will be in ascending order.
+     * If `start` and `end` are %NULL, then they are not filled in, but the
+     * return value still indicates whether text is selected.
+     * @param start - iterator to initialize with selection start
+     * @param end - iterator to initialize with selection end
+     */
     getSelectionBounds(start: Ref<TextIter>, end: Ref<TextIter>): boolean;
+    /**
+     * Get a content provider for this buffer.
+     *
+     * It can be used to make the content of `buffer` available
+     * in a `GdkClipboard`, see [method@Gdk.Clipboard.set_content].
+     */
     getSelectionContent(): Gdk.ContentProvider;
+    /**
+     * Returns the text in the range [@start,@end).
+     *
+     * Excludes undisplayed text (text marked with tags that set the
+     * invisibility attribute) if `include_hidden_chars` is %FALSE.
+     * The returned string includes a 0xFFFC character whenever the
+     * buffer contains embedded images, so byte and character indexes
+     * into the returned string do correspond to byte and character
+     * indexes into the buffer. Contrast with [method@Gtk.TextBuffer.get_text].
+     * 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 start - start of a range
+     * @param end - end of a range
+     * @param includeHiddenChars - whether to include invisible text
+     */
     getSlice(start: TextIter, end: TextIter, includeHiddenChars: boolean): string;
+    /**
+     * Initialized `iter` with the first position in the text buffer.
+     *
+     * This is the same as using [method@Gtk.TextBuffer.get_iter_at_offset]
+     * to get the iter at character offset 0.
+     * @param iter - iterator to initialize
+     */
     getStartIter(iter: Ref<TextIter>): void;
+    /**
+     * Get the `GtkTextTagTable` associated with this buffer.
+     */
     getTagTable(): TextTagTable;
+    /**
+     * Returns the text in the range [@start,@end).
+     *
+     * Excludes undisplayed text (text marked with tags that set the
+     * invisibility attribute) if `include_hidden_chars` is %FALSE.
+     * Does not include characters representing embedded images, so
+     * byte and character indexes into the returned string do not
+     * correspond to byte and character indexes into the buffer.
+     * Contrast with [method@Gtk.TextBuffer.get_slice].
+     * @param start - start of a range
+     * @param end - end of a range
+     * @param includeHiddenChars - whether to include invisible text
+     */
     getText(start: TextIter, end: TextIter, includeHiddenChars: boolean): string;
+    /**
+     * Inserts `len` bytes of `text` at position @iter.
+     *
+     * If `len` is -1, `text` must be nul-terminated and will be inserted in its
+     * entirety. Emits the “insert-text” signal; insertion actually occurs
+     * in the default handler for the signal. `iter` is invalidated when
+     * insertion occurs (because the buffer contents change), but the
+     * default signal handler revalidates it to point to the end of the
+     * inserted text.
+     * @param iter - a position in the buffer
+     * @param text - text in UTF-8 format
+     * @param len - length of text in bytes, or -1
+     */
     insert(iter: TextIter, text: string, len: number): void;
+    /**
+     * Inserts `text` in @buffer.
+     *
+     * Simply calls [method@Gtk.TextBuffer.insert],
+     * using the current cursor position as the insertion point.
+     * @param text - text in UTF-8 format
+     * @param len - length of text, in bytes
+     */
     insertAtCursor(text: string, len: number): void;
+    /**
+     * Inserts a child widget anchor into the text buffer at @iter.
+     *
+     * The anchor will be counted as one character in character counts, and
+     * when obtaining the buffer contents as a string, will be represented
+     * by the Unicode “object replacement character” 0xFFFC. Note that the
+     * “slice” variants for obtaining portions of the buffer as a string
+     * include this character for child anchors, but the “text” variants do
+     * not. E.g. see [method@Gtk.TextBuffer.get_slice] and
+     * [method@Gtk.TextBuffer.get_text].
+     *
+     * Consider [method@Gtk.TextBuffer.create_child_anchor] as a more
+     * convenient alternative to this function. The buffer will add a
+     * reference to the anchor, so you can unref it after insertion.
+     * @param iter - location to insert the anchor
+     * @param anchor - a `GtkTextChildAnchor`
+     */
     insertChildAnchor(iter: TextIter, anchor: TextChildAnchor): void;
+    /**
+     * Inserts `text` in @buffer.
+     *
+     * Like [method@Gtk.TextBuffer.insert], but the insertion will not occur
+     * if `iter` is at a non-editable location in the buffer. Usually you
+     * want to prevent insertions at ineditable locations if the insertion
+     * results from a user action (is interactive).
+     *
+     * `default_editable` indicates the editability of text that doesn't
+     * have a tag affecting editability applied to it. Typically the
+     * result of [method@Gtk.TextView.get_editable] is appropriate here.
+     * @param iter - a position in @buffer
+     * @param text - some UTF-8 text
+     * @param len - length of text in bytes, or -1
+     * @param defaultEditable - default editability of buffer
+     */
     insertInteractive(iter: TextIter, text: string, len: number, defaultEditable: boolean): boolean;
+    /**
+     * Inserts `text` in @buffer.
+     *
+     * Calls [method@Gtk.TextBuffer.insert_interactive]
+     * at the cursor position.
+     *
+     * `default_editable` indicates the editability of text that doesn't
+     * have a tag affecting editability applied to it. Typically the
+     * result of [method@Gtk.TextView.get_editable] is appropriate here.
+     * @param text - text in UTF-8 format
+     * @param len - length of text in bytes, or -1
+     * @param defaultEditable - default editability of buffer
+     */
     insertInteractiveAtCursor(text: string, len: number, defaultEditable: boolean): boolean;
+    /**
+     * Inserts the text in `markup` at position @iter.
+     *
+     * `markup` will be inserted in its entirety and must be nul-terminated
+     * and valid UTF-8. Emits the [signal@Gtk.TextBuffer::insert-text] signal,
+     * possibly multiple times; insertion actually occurs in the default handler
+     * for the signal. `iter` will point to the end of the inserted text on return.
+     * @param iter - location to insert the markup
+     * @param markup - a nul-terminated UTF-8 string containing Pango markup
+     * @param len - length of `markup` in bytes, or -1
+     */
     insertMarkup(iter: TextIter, markup: string, len: number): void;
+    /**
+     * Inserts an image into the text buffer at @iter.
+     *
+     * The image will be counted as one character in character counts,
+     * and when obtaining the buffer contents as a string, will be
+     * represented by the Unicode “object replacement character” 0xFFFC.
+     * Note that the “slice” variants for obtaining portions of the buffer
+     * as a string include this character for paintable, but the “text”
+     * variants do not. e.g. see [method@Gtk.TextBuffer.get_slice] and
+     * [method@Gtk.TextBuffer.get_text].
+     * @param iter - location to insert the paintable
+     * @param paintable - a `GdkPaintable`
+     */
     insertPaintable(iter: TextIter, paintable: Gdk.Paintable): void;
+    /**
+     * Copies text, tags, and paintables between `start` and `end` and inserts the copy at @iter.
+     *
+     * The order of `start` and `end` doesn’t matter.
+     *
+     * Used instead of simply getting/inserting text because it preserves
+     * images and tags. If `start` and `end` are in a different buffer from
+     * @buffer, the two buffers must share the same tag table.
+     *
+     * Implemented via emissions of the ::insert-text and ::apply-tag signals,
+     * so expect those.
+     * @param iter - a position in @buffer
+     * @param start - a position in a `GtkTextBuffer`
+     * @param end - another position in the same buffer as @start
+     */
     insertRange(iter: TextIter, start: TextIter, end: TextIter): void;
+    /**
+     * Copies text, tags, and paintables between `start` and `end` and inserts the copy at @iter.
+     *
+     * Same as [method@Gtk.TextBuffer.insert_range], but does nothing
+     * if the insertion point isn’t editable. The `default_editable` parameter indicates whether the text is editable at `iter` if
+     * no tags enclosing `iter` affect editability. Typically the result
+     * of [method@Gtk.TextView.get_editable] is appropriate here.
+     * @param iter - a position in @buffer
+     * @param start - a position in a `GtkTextBuffer`
+     * @param end - another position in the same buffer as @start
+     * @param defaultEditable - default editability of the buffer
+     */
     insertRangeInteractive(iter: TextIter, start: TextIter, end: TextIter, defaultEditable: boolean): boolean;
+    /**
+     * Moves `mark` to the new location @where.
+     *
+     * Emits the [signal@Gtk.TextBuffer::mark-set] signal
+     * as notification of the move.
+     * @param mark - a `GtkTextMark`
+     * @param where - new location for `mark` in @buffer
+     */
     moveMark(mark: TextMark, where: TextIter): void;
+    /**
+     * Moves the mark named `name` (which must exist) to location @where.
+     *
+     * See [method@Gtk.TextBuffer.move_mark] for details.
+     * @param name - name of a mark
+     * @param where - new location for mark
+     */
     moveMarkByName(name: string, where: TextIter): void;
+    /**
+     * Pastes the contents of a clipboard.
+     *
+     * If `override_location` is %NULL, the pasted text will be inserted
+     * at the cursor position, or the buffer selection will be replaced
+     * if the selection is non-empty.
+     *
+     * Note: pasting is asynchronous, that is, we’ll ask for the paste data
+     * and return, and at some point later after the main loop runs, the paste
+     * data will be inserted.
+     * @param clipboard - the `GdkClipboard` to paste from
+     * @param overrideLocation - location to insert pasted text
+     * @param defaultEditable - whether the buffer is editable by default
+     */
     pasteClipboard(clipboard: Gdk.Clipboard, defaultEditable: boolean, overrideLocation?: TextIter | null): void;
+    /**
+     * This function moves the “insert” and “selection_bound” marks
+     * simultaneously.
+     *
+     * If you move them to the same place in two steps with
+     * [method@Gtk.TextBuffer.move_mark], you will temporarily select a
+     * region in between their old and new locations, which can be pretty
+     * inefficient since the temporarily-selected region will force stuff
+     * to be recalculated. This function moves them as a unit, which can
+     * be optimized.
+     * @param where - where to put the cursor
+     */
     placeCursor(where: TextIter): void;
+    /**
+     * Redoes the next redoable action on the buffer, if there is one.
+     */
     redo(): void;
+    /**
+     * Removes all tags in the range between `start` and @end.
+     *
+     * Be careful with this function; it could remove tags added in code
+     * unrelated to the code you’re currently writing. That is, using this
+     * function is probably a bad idea if you have two or more unrelated
+     * code sections that add tags.
+     * @param start - one bound of range to be untagged
+     * @param end - other bound of range to be untagged
+     */
     removeAllTags(start: TextIter, end: TextIter): void;
+    /**
+     * Removes the `GtkTextBufferCommitNotify` handler previously registered
+     * with [method@Gtk.TextBuffer.add_commit_notify].
+     *
+     * This may result in the `user_data_destroy` being called that was passed when registering
+     * the commit notify functions.
+     * @param commitNotifyHandler - the notify handler identifier returned from
+     */
     removeCommitNotify(commitNotifyHandler: number): void;
+    /**
+     * Removes a `GdkClipboard` added with
+     * [method@Gtk.TextBuffer.add_selection_clipboard]
+     * @param clipboard - a `GdkClipboard` added to `buffer` by
+     */
     removeSelectionClipboard(clipboard: Gdk.Clipboard): void;
+    /**
+     * Emits the “remove-tag” signal.
+     *
+     * The default handler for the signal removes all occurrences
+     * of `tag` from the given range. `start` and `end` don’t have
+     * to be in order.
+     * @param tag - a `GtkTextTag`
+     * @param start - one bound of range to be untagged
+     * @param end - other bound of range to be untagged
+     */
     removeTag(tag: TextTag, start: TextIter, end: TextIter): void;
+    /**
+     * Emits the “remove-tag” signal.
+     *
+     * Calls [method@Gtk.TextTagTable.lookup] on the buffer’s
+     * tag table to get a `GtkTextTag`, then calls
+     * [method@Gtk.TextBuffer.remove_tag].
+     * @param name - name of a `GtkTextTag`
+     * @param start - one bound of range to be untagged
+     * @param end - other bound of range to be untagged
+     */
     removeTagByName(name: string, start: TextIter, end: TextIter): void;
+    /**
+     * This function moves the “insert” and “selection_bound” marks
+     * simultaneously.
+     *
+     * If you move them in two steps with
+     * [method@Gtk.TextBuffer.move_mark], you will temporarily select a
+     * region in between their old and new locations, which can be pretty
+     * inefficient since the temporarily-selected region will force stuff
+     * to be recalculated. This function moves them as a unit, which can
+     * be optimized.
+     * @param ins - where to put the “insert” mark
+     * @param bound - where to put the “selection_bound” mark
+     */
     selectRange(ins: TextIter, bound: TextIter): void;
+    /**
+     * Sets whether or not to enable undoable actions in the text buffer.
+     *
+     * Undoable actions in this context are changes to the text content of
+     * the buffer. Changes to tags and marks are not tracked.
+     *
+     * If enabled, the user will be able to undo the last number of actions
+     * up to [method@Gtk.TextBuffer.get_max_undo_levels].
+     *
+     * See [method@Gtk.TextBuffer.begin_irreversible_action] and
+     * [method@Gtk.TextBuffer.end_irreversible_action] to create
+     * changes to the buffer that cannot be undone.
+     * @param enableUndo - %TRUE to enable undo
+     */
     setEnableUndo(enableUndo: boolean): void;
+    /**
+     * Sets the maximum number of undo levels to perform.
+     *
+     * If 0, unlimited undo actions may be performed. Note that this may
+     * have a memory usage impact as it requires storing an additional
+     * copy of the inserted or removed text within the text buffer.
+     * @param maxUndoLevels - the maximum number of undo actions to perform
+     */
     setMaxUndoLevels(maxUndoLevels: number): void;
+    /**
+     * Used to keep track of whether the buffer has been
+     * modified since the last time it was saved.
+     *
+     * Whenever the buffer is saved to disk, call
+     * `gtk_text_buffer_set_modified (@buffer, FALSE)`.
+     * When the buffer is modified, it will automatically
+     * toggle on the modified bit again. When the modified
+     * bit flips, the buffer emits the
+     * [signal@Gtk.TextBuffer::modified-changed] signal.
+     * @param setting - modification flag setting
+     */
     setModified(setting: boolean): void;
+    /**
+     * Deletes current contents of @buffer, and inserts `text` instead. This is
+     * automatically marked as an irreversible action in the undo stack. If you
+     * wish to mark this action as part of a larger undo operation, call
+     * [method@TextBuffer.delete] and [method@TextBuffer.insert] directly instead.
+     *
+     * If `len` is -1, `text` must be nul-terminated.
+     * `text` must be valid UTF-8.
+     * @param text - UTF-8 text to insert
+     * @param len - length of `text` in bytes
+     */
     setText(text: string, len: number): void;
+    /**
+     * Undoes the last undoable action on the buffer, if there is one.
+     */
     undo(): void;
     connect(signal: "apply-tag", handler: (self: TextBuffer, tag: TextTag, start: TextIter, end: TextIter) => void, after?: boolean): number;
     connect(signal: "begin-user-action", handler: (self: TextBuffer) => void, after?: boolean): number;