@gtkx/ffi 0.10.5 → 0.11.1

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

@@ -1,17 +1,90 @@
 import { Ref } from "@gtkx/native";
-import { AccessibleTextContentChange, DeleteType, DirectionType, InputHints, InputPurpose, Justification, MovementStep, ScrollStep, ScrollablePolicy, StateFlags, TextDirection, TextExtendSelection, TextWindowType, WrapMode } from "./enums.js";
+import { AccessibleTextContentChange, DeleteType, InputHints, InputPurpose, Justification, MovementStep, ScrollStep, ScrollablePolicy, TextExtendSelection, TextWindowType, WrapMode } from "./enums.js";
 import { Border } from "./border.js";
 import { TextIter } from "./text-iter.js";
+import { Widget } from "./widget.js";
 import { Adjustment } from "./adjustment.js";
 import { TextBuffer } from "./text-buffer.js";
 import { TextChildAnchor } from "./text-child-anchor.js";
 import { TextMark } from "./text-mark.js";
-import { Tooltip } from "./tooltip.js";
-import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
-import { Widget } from "./widget.js";
+/**
+ * Displays the contents of a {@link Gtk.TextBuffer}.
+ *
+ * ![An example GtkTextView](https://docs.gtk.org/gtk4/multiline-text.png)
+ *
+ * You may wish to begin by reading the conceptual overview,
+ * which gives an overview of all the objects and data types related to the
+ * text widget and how they work together.
+ *
+ * ## Shortcuts and Gestures
+ *
+ * `GtkTextView` supports the following keyboard shortcuts:
+ *
+ * - `Shift`+`F10` or `Menu` opens the context menu.
+ * - `Ctrl`+`Z` undoes the last modification.
+ * - `Ctrl`+`Y` or `Ctrl`+`Shift`+`Z`
+ *    redoes the last undone modification.
+ * - `Clear` clears the content.
+ *
+ * Additionally, the following signals have default keybindings:
+ *
+ * - {@link Gtk.TextView.:backspace}
+ * - {@link Gtk.TextView.:copy-clipboard}
+ * - {@link Gtk.TextView.:cut-clipboard}
+ * - {@link Gtk.TextView.:delete-from-cursor}
+ * - {@link Gtk.TextView.:insert-emoji}
+ * - {@link Gtk.TextView.:move-cursor}
+ * - {@link Gtk.TextView.:paste-clipboard}
+ * - {@link Gtk.TextView.:select-all}
+ * - {@link Gtk.TextView.:toggle-cursor-visible}
+ * - {@link Gtk.TextView.:toggle-overwrite}
+ *
+ * ## Actions
+ *
+ * `GtkTextView` defines a set of built-in actions:
+ *
+ * - `clipboard.copy` copies the contents to the clipboard.
+ * - `clipboard.cut` copies the contents to the clipboard and deletes it from
+ *   the widget.
+ * - `clipboard.paste` inserts the contents of the clipboard into the widget.
+ * - `menu.popup` opens the context menu.
+ * - `misc.insert-emoji` opens the Emoji chooser.
+ * - `selection.delete` deletes the current selection.
+ * - `selection.select-all` selects all of the widgets content.
+ * - `text.redo` redoes the last change to the contents.
+ * - `text.undo` undoes the last change to the contents.
+ * - `text.clear` clears the content.
+ *
+ * ## CSS nodes
+ *
+ * ```
+ * textview.view
+ * ├── border.top
+ * ├── border.left
+ * ├── text
+ * │   ╰── [selection]
+ * ├── border.right
+ * ├── border.bottom
+ * ╰── [window.popup]
+ * ```
+ *
+ * `GtkTextView` has a main css node with name textview and style class .view,
+ * and subnodes for each of the border windows, and the main text area,
+ * with names border and text, respectively. The border nodes each get
+ * one of the style classes .left, .right, .top or .bottom.
+ *
+ * A node representing the selection will appear below the text node.
+ *
+ * If a context menu is opened, the window node will appear as a subnode
+ * of the main node.
+ *
+ * ## Accessibility
+ *
+ * `GtkTextView` uses the {@link Gtk.AccessibleRole.text_box} role.
+ */
 export declare class TextView extends Widget {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -31,14 +104,9 @@ export declare class TextView extends Widget {
      * to create a default buffer, in which case this function is equivalent
      * to {@link Gtk.TextView.new}. The text view adds its own reference count
      * to the buffer; it does not take over an existing reference.
-     * @param buffer - a `GtkTextBuffer`
-     */
-    static viewNewWithBuffer(buffer: TextBuffer): TextView;
-    /**
-     * Adds a child widget in the text buffer, at the given `anchor`.
-     * @param child - a `GtkWidget`
-     * @param anchor - a `GtkTextChildAnchor` in the `GtkTextBuffer` for `text_view`
      */
+    static newWithBuffer(buffer: TextBuffer): TextView;
+    /** Adds a child widget in the text buffer, at the given `anchor`. */
     addChildAtAnchor(child: Widget, anchor: TextChildAnchor): void;
     /**
      * Adds `child` at a fixed coordinate in the `GtkTextView`'s text window.
@@ -51,9 +119,6 @@ export declare class TextView extends Widget {
      *
      * If instead you want a widget that will not move with the
      * `GtkTextView` contents see `GtkOverlay`.
-     * @param child - a `GtkWidget`
-     * @param xpos - X position of child in window coordinates
-     * @param ypos - Y position of child in window coordinates
      */
     addOverlay(child: Widget, xpos: number, ypos: number): void;
     /**
@@ -66,7 +131,6 @@ export declare class TextView extends Widget {
      * same. Display lines are divided differently for each view, since
      * they depend on the view’s width; paragraphs are the same in all
      * views, since they depend on the contents of the `GtkTextBuffer`.
-     * @param iter - a `GtkTextIter`
      */
     backwardDisplayLine(iter: TextIter): boolean;
     /**
@@ -79,18 +143,10 @@ export declare class TextView extends Widget {
      * same. Display lines are divided differently for each view, since
      * they depend on the view’s width; paragraphs are the same in all
      * views, since they depend on the contents of the `GtkTextBuffer`.
-     * @param iter - a `GtkTextIter`
      */
     backwardDisplayLineStart(iter: TextIter): boolean;
-    /**
-     * Converts buffer coordinates to window coordinates.
-     * @param win - a `GtkTextWindowType`
-     * @param bufferX - buffer x coordinate
-     * @param bufferY - buffer y coordinate
-     * @param windowX - window x coordinate return location
-     * @param windowY - window y coordinate return location
-     */
-    bufferToWindowCoords(win: TextWindowType, bufferX: number, bufferY: number, windowX?: Ref<number>, windowY?: Ref<number>): void;
+    /** Converts buffer coordinates to window coordinates. */
+    bufferToWindowCoords(win: TextWindowType, bufferX: number, bufferY: number, windowX?: Ref<number> | null, windowY?: Ref<number> | null): void;
     /**
      * Moves the given `iter` forward by one display (wrapped) line.
      *
@@ -101,7 +157,6 @@ export declare class TextView extends Widget {
      * same. Display lines are divided differently for each view, since
      * they depend on the view’s width; paragraphs are the same in all
      * views, since they depend on the contents of the `GtkTextBuffer`.
-     * @param iter - a `GtkTextIter`
      */
     forwardDisplayLine(iter: TextIter): boolean;
     /**
@@ -114,7 +169,6 @@ export declare class TextView extends Widget {
      * same. Display lines are divided differently for each view, since
      * they depend on the view’s width; paragraphs are the same in all
      * views, since they depend on the contents of the `GtkTextBuffer`.
-     * @param iter - a `GtkTextIter`
      */
     forwardDisplayLineEnd(iter: TextIter): boolean;
     /**
@@ -123,9 +177,7 @@ export declare class TextView extends Widget {
      * See {@link Gtk.TextView.set_accepts_tab}.
      */
     getAcceptsTab(): boolean;
-    /**
-     * Gets the bottom margin for text in the `text_view`.
-     */
+    /** Gets the bottom margin for text in the `text_view`. */
     getBottomMargin(): number;
     /**
      * Returns the `GtkTextBuffer` being displayed by this text view.
@@ -155,14 +207,9 @@ export declare class TextView extends Widget {
      * The rectangle position is in buffer coordinates; use
      * {@link Gtk.TextView.buffer_to_window_coords} to convert these
      * coordinates to coordinates for one of the windows in the text view.
-     * @param iter - a `GtkTextIter`
-     * @param strong - location to store the strong cursor position
-     * @param weak - location to store the weak cursor position
-     */
-    getCursorLocations(iter?: TextIter, strong?: Gdk.Rectangle, weak?: Gdk.Rectangle): void;
-    /**
-     * Find out whether the cursor should be displayed.
      */
+    getCursorLocations(iter?: TextIter | null, strong?: Gdk.Rectangle | null, weak?: Gdk.Rectangle | null): void;
+    /** Find out whether the cursor should be displayed. */
     getCursorVisible(): boolean;
     /**
      * Returns the default editability of the `GtkTextView`.
@@ -182,7 +229,6 @@ export declare class TextView extends Widget {
      *
      * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
      * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
-     * @param win - a `GtkTextWindowType`
      */
     getGutter(win: TextWindowType): Widget | null;
     /**
@@ -192,13 +238,9 @@ export declare class TextView extends Widget {
      * The indentation may be negative.
      */
     getIndent(): number;
-    /**
-     * Gets the `input-hints` of the `GtkTextView`.
-     */
+    /** Gets the `input-hints` of the `GtkTextView`. */
     getInputHints(): InputHints;
-    /**
-     * Gets the `input-purpose` of the `GtkTextView`.
-     */
+    /** Gets the `input-purpose` of the `GtkTextView`. */
     getInputPurpose(): InputPurpose;
     /**
      * Retrieves the iterator at buffer coordinates `x` and `y`.
@@ -207,9 +249,6 @@ export declare class TextView extends Widget {
      * the currently-displayed portion. If you have coordinates from an
      * event, you have to convert those to buffer coordinates with
      * {@link Gtk.TextView.window_to_buffer_coords}.
-     * @param iter - a `GtkTextIter`
-     * @param x - x position, in buffer coordinates
-     * @param y - y position, in buffer coordinates
      */
     getIterAtLocation(iter: TextIter, x: number, y: number): boolean;
     /**
@@ -223,20 +262,14 @@ export declare class TextView extends Widget {
      *
      * Note that this is different from {@link Gtk.TextView.get_iter_at_location},
      * which returns cursor locations, i.e. positions between characters.
-     * @param iter - a `GtkTextIter`
-     * @param trailing - if non-%NULL, location to store
-     * @param x - x position, in buffer coordinates
-     * @param y - y position, in buffer coordinates
      */
-    getIterAtPosition(iter: TextIter, x: number, y: number, trailing?: Ref<number>): boolean;
+    getIterAtPosition(iter: TextIter, x: number, y: number, trailing?: Ref<number> | null): boolean;
     /**
      * Gets a rectangle which roughly contains the character at `iter`.
      *
      * The rectangle position is in buffer coordinates; use
      * {@link Gtk.TextView.buffer_to_window_coords} to convert these
      * coordinates to coordinates for one of the windows in the text view.
-     * @param iter - a `GtkTextIter`
-     * @param location - bounds of the character at `iter`
      */
     getIterLocation(iter: TextIter, location: Gdk.Rectangle): void;
     /**
@@ -259,9 +292,6 @@ export declare class TextView extends Widget {
      * {@link Gtk.TextView.window_to_buffer_coords}. If non-%NULL,
      * `line_top` will be filled with the coordinate of the top edge
      * of the line.
-     * @param targetIter - a `GtkTextIter`
-     * @param y - a y coordinate
-     * @param lineTop - return location for top coordinate of the line
      */
     getLineAtY(targetIter: TextIter, y: number, lineTop: Ref<number>): void;
     /**
@@ -270,9 +300,6 @@ export declare class TextView extends Widget {
      *
      * The coordinate is a buffer coordinate; convert to window
      * coordinates with {@link Gtk.TextView.buffer_to_window_coords}.
-     * @param iter - a `GtkTextIter`
-     * @param y - return location for a y coordinate
-     * @param height - return location for a height
      */
     getLineYrange(iter: TextIter, y: Ref<number>, height: Ref<number>): void;
     /**
@@ -282,13 +309,9 @@ export declare class TextView extends Widget {
      * The context may be replaced when CSS changes occur.
      */
     getLtrContext(): Pango.Context;
-    /**
-     * Gets whether the `GtkTextView` uses monospace styling.
-     */
+    /** Gets whether the `GtkTextView` uses monospace styling. */
     getMonospace(): boolean;
-    /**
-     * Returns whether the `GtkTextView` is in overwrite mode or not.
-     */
+    /** Returns whether the `GtkTextView` is in overwrite mode or not. */
     getOverwrite(): boolean;
     /**
      * Gets the default number of pixels to put above paragraphs.
@@ -330,9 +353,7 @@ export declare class TextView extends Widget {
      * return value with {@link Pango.TabArray.free}.
      */
     getTabs(): Pango.TabArray | null;
-    /**
-     * Gets the top margin for text in the `text_view`.
-     */
+    /** Gets the top margin for text in the `text_view`. */
     getTopMargin(): number;
     /**
      * Gets the X,Y offset in buffer coordinates of the top-left corner of
@@ -344,22 +365,17 @@ export declare class TextView extends Widget {
      *
      * You might want this when making ulterior widgets align with quantized
      * device pixels of the textview contents such as line numbers.
-     * @param xOffset - a location for the X offset
-     * @param yOffset - a location for the Y offset
      */
-    getVisibleOffset(xOffset?: Ref<number>, yOffset?: Ref<number>): void;
+    getVisibleOffset(xOffset?: Ref<number> | null, yOffset?: Ref<number> | null): void;
     /**
      * Fills `visible_rect` with the currently-visible
      * region of the buffer, in buffer coordinates.
      *
      * Convert to window coordinates with
      * {@link Gtk.TextView.buffer_to_window_coords}.
-     * @param visibleRect - rectangle to fill
      */
     getVisibleRect(visibleRect: Gdk.Rectangle): void;
-    /**
-     * Gets the line wrapping for the view.
-     */
+    /** Gets the line wrapping for the view. */
     getWrapMode(): WrapMode;
     /**
      * Allow the `GtkTextView` input method to internally handle key press
@@ -393,22 +409,17 @@ export declare class TextView extends Widget {
      *   return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
      * }
      * ```
-     * @param event - the key event
      */
     imContextFilterKeypress(event: Gdk.Event): boolean;
     /**
      * Moves a mark within the buffer so that it's
      * located within the currently-visible text area.
-     * @param mark - a `GtkTextMark`
      */
     moveMarkOnscreen(mark: TextMark): boolean;
     /**
      * Updates the position of a child.
      *
      * See {@link Gtk.TextView.add_overlay}.
-     * @param child - a widget already added with {@link Gtk.TextView.add_overlay}
-     * @param xpos - new X position in buffer coordinates
-     * @param ypos - new Y position in buffer coordinates
      */
     moveOverlay(child: Widget, xpos: number, ypos: number): void;
     /**
@@ -424,8 +435,6 @@ export declare class TextView extends Widget {
      * between logical and visual order will depend on the direction
      * of the current run, and there may be jumps when the cursor
      * is moved off of the end of a run.
-     * @param iter - a `GtkTextIter`
-     * @param count - number of characters to move (negative moves left,
      */
     moveVisually(iter: TextIter, count: number): boolean;
     /**
@@ -433,10 +442,7 @@ export declare class TextView extends Widget {
      * buffer.
      */
     placeCursorOnscreen(): boolean;
-    /**
-     * Removes a child widget from `text_view`.
-     * @param child - the child to remove
-     */
+    /** Removes a child widget from `text_view`. */
     remove(child: Widget): void;
     /**
      * Ensures that the cursor is shown.
@@ -459,7 +465,6 @@ export declare class TextView extends Widget {
     /**
      * Scrolls `text_view` the minimum distance such that `mark` is contained
      * within the visible area of the widget.
-     * @param mark - a mark in the buffer for `text_view`
      */
     scrollMarkOnscreen(mark: TextMark): void;
     /**
@@ -478,11 +483,6 @@ export declare class TextView extends Widget {
      * called before the height computations. To avoid oddness, consider
      * using {@link Gtk.TextView.scroll_to_mark} which saves a point to be
      * scrolled to after line validation.
-     * @param iter - a `GtkTextIter`
-     * @param withinMargin - margin as a [0.0,0.5) fraction of screen size
-     * @param useAlign - whether to use alignment arguments (if %FALSE,
-     * @param xalign - horizontal alignment of mark within visible area
-     * @param yalign - vertical alignment of mark within visible area
      */
     scrollToIter(iter: TextIter, withinMargin: number, useAlign: boolean, xalign: number, yalign: number): boolean;
     /**
@@ -494,11 +494,6 @@ export declare class TextView extends Widget {
      * the minimal distance to get the mark onscreen, possibly not scrolling
      * at all. The effective screen for purposes of this function is reduced
      * by a margin of size `within_margin`.
-     * @param mark - a `GtkTextMark`
-     * @param withinMargin - margin as a [0.0,0.5) fraction of screen size
-     * @param useAlign - whether to use alignment arguments (if %FALSE, just
-     * @param xalign - horizontal alignment of mark within visible area
-     * @param yalign - vertical alignment of mark within visible area
      */
     scrollToMark(mark: TextMark, withinMargin: number, useAlign: boolean, xalign: number, yalign: number): void;
     /**
@@ -509,7 +504,6 @@ export declare class TextView extends Widget {
      * chain.
      *
      * Focus can always be moved using `Ctrl`+`Tab`.
-     * @param acceptsTab - %TRUE if pressing the Tab key should insert a tab
      */
     setAcceptsTab(acceptsTab: boolean): void;
     /**
@@ -517,7 +511,6 @@ export declare class TextView extends Widget {
      *
      * Note that this function is confusingly named.
      * In CSS terms, the value set here is padding.
-     * @param bottomMargin - bottom margin in pixels
      */
     setBottomMargin(bottomMargin: number): void;
     /**
@@ -527,9 +520,8 @@ export declare class TextView extends Widget {
      * a reference is added to `buffer`. If you owned a reference to `buffer`
      * before passing it to this function, you must remove that reference
      * yourself; `GtkTextView` will not “adopt” it.
-     * @param buffer - a `GtkTextBuffer`
      */
-    setBuffer(buffer?: TextBuffer): void;
+    setBuffer(buffer?: TextBuffer | null): void;
     /**
      * Toggles whether the insertion point should be displayed.
      *
@@ -538,7 +530,6 @@ export declare class TextView extends Widget {
      *
      * Note that this property may be overridden by the
      * {@link Gtk.Settings.gtk-keynav-use-caret} setting.
-     * @param setting - whether to show the insertion cursor
      */
     setCursorVisible(setting: boolean): void;
     /**
@@ -546,7 +537,6 @@ export declare class TextView extends Widget {
      *
      * You can override this default setting with tags in the buffer,
      * using the “editable” attribute of tags.
-     * @param setting - whether it’s editable
      */
     setEditable(setting: boolean): void;
     /**
@@ -554,23 +544,19 @@ export declare class TextView extends Widget {
      * menu for `text_view`.
      *
      * You can pass %NULL to remove a previously set extra menu.
-     * @param model - a `GMenuModel`
      */
-    setExtraMenu(model?: Gio.MenuModel): void;
+    setExtraMenu(model?: Gio.MenuModel | null): void;
     /**
      * Places `widget` into the gutter specified by `win`.
      *
      * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
      * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
-     * @param win - a `GtkTextWindowType`
-     * @param widget - a `GtkWidget`
      */
-    setGutter(win: TextWindowType, widget?: Widget): void;
+    setGutter(win: TextWindowType, widget?: Widget | null): void;
     /**
      * Sets the default indentation for paragraphs in `text_view`.
      *
      * Tags in the buffer may override the default.
-     * @param indent - indentation in pixels
      */
     setIndent(indent: number): void;
     /**
@@ -578,7 +564,6 @@ export declare class TextView extends Widget {
      *
      * The `input-hints` allow input methods to fine-tune
      * their behaviour.
-     * @param hints - the hints
      */
     setInputHints(hints: InputHints): void;
     /**
@@ -586,14 +571,12 @@ export declare class TextView extends Widget {
      *
      * The `input-purpose` can be used by on-screen keyboards
      * and other input methods to adjust their behaviour.
-     * @param purpose - the purpose
      */
     setInputPurpose(purpose: InputPurpose): void;
     /**
      * Sets the default justification of text in `text_view`.
      *
      * Tags in the view’s buffer may override the default.
-     * @param justification - justification
      */
     setJustification(justification: Justification): void;
     /**
@@ -603,25 +586,19 @@ export declare class TextView extends Widget {
      *
      * Note that this function is confusingly named.
      * In CSS terms, the value set here is padding.
-     * @param leftMargin - left margin in pixels
      */
     setLeftMargin(leftMargin: number): void;
     /**
      * Sets whether the `GtkTextView` should display text in
      * monospace styling.
-     * @param monospace - %TRUE to request monospace styling
      */
     setMonospace(monospace: boolean): void;
-    /**
-     * Changes the `GtkTextView` overwrite mode.
-     * @param overwrite - %TRUE to turn on overwrite mode, %FALSE to turn it off
-     */
+    /** Changes the `GtkTextView` overwrite mode. */
     setOverwrite(overwrite: boolean): void;
     /**
      * Sets the default number of blank pixels above paragraphs in `text_view`.
      *
      * Tags in the buffer for `text_view` may override the defaults.
-     * @param pixelsAboveLines - pixels above paragraphs
      */
     setPixelsAboveLines(pixelsAboveLines: number): void;
     /**
@@ -629,7 +606,6 @@ export declare class TextView extends Widget {
      * to put below paragraphs in `text_view`.
      *
      * May be overridden by tags applied to `text_view`’s buffer.
-     * @param pixelsBelowLines - pixels below paragraphs
      */
     setPixelsBelowLines(pixelsBelowLines: number): void;
     /**
@@ -637,7 +613,6 @@ export declare class TextView extends Widget {
      * display/wrapped lines within a paragraph.
      *
      * May be overridden by tags in `text_view`’s buffer.
-     * @param pixelsInsideWrap - default number of pixels between wrapped lines
      */
     setPixelsInsideWrap(pixelsInsideWrap: number): void;
     /**
@@ -647,14 +622,12 @@ export declare class TextView extends Widget {
      *
      * Note that this function is confusingly named.
      * In CSS terms, the value set here is padding.
-     * @param rightMargin - right margin in pixels
      */
     setRightMargin(rightMargin: number): void;
     /**
      * Sets the default tab stops for paragraphs in `text_view`.
      *
      * Tags in the buffer may override the default.
-     * @param tabs - tabs as a `PangoTabArray`
      */
     setTabs(tabs: Pango.TabArray): void;
     /**
@@ -662,32 +635,22 @@ export declare class TextView extends Widget {
      *
      * Note that this function is confusingly named.
      * In CSS terms, the value set here is padding.
-     * @param topMargin - top margin in pixels
      */
     setTopMargin(topMargin: number): void;
-    /**
-     * Sets the line wrapping for the view.
-     * @param wrapMode - a `GtkWrapMode`
-     */
+    /** Sets the line wrapping for the view. */
     setWrapMode(wrapMode: WrapMode): void;
     /**
      * Determines whether `iter` is at the start of a display line.
      *
      * See {@link Gtk.TextView.forward_display_line} for an
      * explanation of display lines vs. paragraphs.
-     * @param iter - a `GtkTextIter`
      */
     startsDisplayLine(iter: TextIter): boolean;
     /**
      * Converts coordinates on the window identified by `win` to buffer
      * coordinates.
-     * @param win - a `GtkTextWindowType`
-     * @param windowX - window x coordinate
-     * @param windowY - window y coordinate
-     * @param bufferX - buffer x coordinate return location
-     * @param bufferY - buffer y coordinate return location
      */
-    windowToBufferCoords(win: TextWindowType, windowX: number, windowY: number, bufferX?: Ref<number>, bufferY?: Ref<number>): void;
+    windowToBufferCoords(win: TextWindowType, windowX: number, windowY: number, bufferX?: Ref<number> | null, bufferY?: Ref<number> | null): void;
     /**
      * Updates the position of the caret.
      *
@@ -706,9 +669,6 @@ export declare class TextView extends Widget {
      * Note: If the change is a deletion, this function must be called *before*
      * removing the contents, if it is an insertion, it must be called *after*
      * inserting the new contents.
-     * @param change - the type of change in the contents
-     * @param start - the starting offset of the change, in characters
-     * @param end - the end offset of the change, in characters
      */
     updateContents(change: AccessibleTextContentChange, start: number, end: number): void;
     /**
@@ -726,49 +686,32 @@ export declare class TextView extends Widget {
      * An example for this would be treeview headers. GTK can use
      * this information to display overlaid graphics, like the
      * overshoot indication, at the right position.
-     * @param border - return location for the results
      */
     getBorder(border: Border): boolean;
-    /**
-     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
-     */
+    /** Retrieves the `GtkAdjustment` used for horizontal scrolling. */
     getHadjustment(): Adjustment | null;
-    /**
-     * Gets the horizontal `GtkScrollablePolicy`.
-     */
+    /** Gets the horizontal `GtkScrollablePolicy`. */
     getHscrollPolicy(): ScrollablePolicy;
-    /**
-     * Retrieves the `GtkAdjustment` used for vertical scrolling.
-     */
+    /** Retrieves the `GtkAdjustment` used for vertical scrolling. */
     getVadjustment(): Adjustment | null;
-    /**
-     * Gets the vertical `GtkScrollablePolicy`.
-     */
+    /** Gets the vertical `GtkScrollablePolicy`. */
     getVscrollPolicy(): ScrollablePolicy;
-    /**
-     * Sets the horizontal adjustment of the `GtkScrollable`.
-     * @param hadjustment - a `GtkAdjustment`
-     */
-    setHadjustment(hadjustment?: Adjustment): void;
+    /** Sets the horizontal adjustment of the `GtkScrollable`. */
+    setHadjustment(hadjustment?: Adjustment | null): void;
     /**
      * Sets the `GtkScrollablePolicy`.
      *
      * The policy determines whether horizontal scrolling should start
      * below the minimum width or below the natural width.
-     * @param policy - the horizontal `GtkScrollablePolicy`
      */
     setHscrollPolicy(policy: ScrollablePolicy): void;
-    /**
-     * Sets the vertical adjustment of the `GtkScrollable`.
-     * @param vadjustment - a `GtkAdjustment`
-     */
-    setVadjustment(vadjustment?: Adjustment): void;
+    /** Sets the vertical adjustment of the `GtkScrollable`. */
+    setVadjustment(vadjustment?: Adjustment | null): void;
     /**
      * Sets the `GtkScrollablePolicy`.
      *
      * The policy determines whether vertical scrolling should start
      * below the minimum height or below the natural height.
-     * @param policy - the vertical `GtkScrollablePolicy`
      */
     setVscrollPolicy(policy: ScrollablePolicy): void;
     connect(signal: "backspace", handler: (self: TextView) => void, after?: boolean): number;
@@ -786,19 +729,5 @@ export declare class TextView extends Widget {
     connect(signal: "set-anchor", handler: (self: TextView) => void, after?: boolean): number;
     connect(signal: "toggle-cursor-visible", handler: (self: TextView) => void, after?: boolean): number;
     connect(signal: "toggle-overwrite", handler: (self: TextView) => void, after?: boolean): number;
-    connect(signal: "destroy", handler: (self: TextView) => void, after?: boolean): number;
-    connect(signal: "direction-changed", handler: (self: TextView, previousDirection: TextDirection) => void, after?: boolean): number;
-    connect(signal: "hide", handler: (self: TextView) => void, after?: boolean): number;
-    connect(signal: "keynav-failed", handler: (self: TextView, direction: DirectionType) => boolean, after?: boolean): number;
-    connect(signal: "map", handler: (self: TextView) => void, after?: boolean): number;
-    connect(signal: "mnemonic-activate", handler: (self: TextView, groupCycling: boolean) => boolean, after?: boolean): number;
-    connect(signal: "move-focus", handler: (self: TextView, direction: DirectionType) => void, after?: boolean): number;
-    connect(signal: "query-tooltip", handler: (self: TextView, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
-    connect(signal: "realize", handler: (self: TextView) => void, after?: boolean): number;
-    connect(signal: "show", handler: (self: TextView) => void, after?: boolean): number;
-    connect(signal: "state-flags-changed", handler: (self: TextView, flags: StateFlags) => void, after?: boolean): number;
-    connect(signal: "unmap", handler: (self: TextView) => void, after?: boolean): number;
-    connect(signal: "unrealize", handler: (self: TextView) => void, after?: boolean): number;
-    connect(signal: "notify", handler: (self: TextView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }