@gtkx/ffi 0.10.5 → 0.11.1

package/dist/generated/gtk/entry.d.ts

@@ -1,29 +1,109 @@
 import { Ref } from "@gtkx/native";
-import { AccessiblePlatformState, DirectionType, EntryIconPosition, ImageType, InputHints, InputPurpose, StateFlags, TextDirection } from "./enums.js";
+import { AccessiblePlatformState, EntryIconPosition, ImageType, InputHints, InputPurpose } from "./enums.js";
 import { Editable } from "./editable.js";
+import { Widget } from "./widget.js";
 import { EntryBuffer } from "./entry-buffer.js";
 import { EntryCompletion } from "./entry-completion.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";
+/**
+ * A single-line text entry widget.
+ *
+ * ![An example GtkEntry](https://docs.gtk.org/gtk4/entry.png)
+ *
+ * A fairly large set of key bindings are supported by default. If the
+ * entered text is longer than the allocation of the widget, the widget
+ * will scroll so that the cursor position is visible.
+ *
+ * When using an entry for passwords and other sensitive information, it
+ * can be put into “password mode” using {@link Gtk.Entry.set_visibility}.
+ * In this mode, entered text is displayed using a “invisible” character.
+ * By default, GTK picks the best invisible character that is available
+ * in the current font, but it can be changed with
+ * {@link Gtk.Entry.set_invisible_char}.
+ *
+ * `GtkEntry` has the ability to display progress or activity
+ * information behind the text. To make an entry display such information,
+ * use {@link Gtk.Entry.set_progress_fraction} or
+ * {@link Gtk.Entry.set_progress_pulse_step}.
+ *
+ * Additionally, `GtkEntry` can show icons at either side of the entry.
+ * These icons can be activatable by clicking, can be set up as drag source
+ * and can have tooltips. To add an icon, use
+ * {@link Gtk.Entry.set_icon_from_gicon} or one of the various other functions
+ * that set an icon from an icon name or a paintable. To trigger an action when
+ * the user clicks an icon, connect to the {@link Gtk.Entry.:icon-press} signal.
+ * To allow DND operations from an icon, use
+ * {@link Gtk.Entry.set_icon_drag_source}. To set a tooltip on an icon, use
+ * {@link Gtk.Entry.set_icon_tooltip_text} or the corresponding function
+ * for markup.
+ *
+ * Note that functionality or information that is only available by clicking
+ * on an icon in an entry may not be accessible at all to users which are not
+ * able to use a mouse or other pointing device. It is therefore recommended
+ * that any such functionality should also be available by other means, e.g.
+ * via the context menu of the entry.
+ *
+ * # CSS nodes
+ *
+ * ```
+ * entry[.flat][.warning][.error]
+ * ├── text[.readonly]
+ * ├── image.left
+ * ├── image.right
+ * ╰── [progress[.pulse]]
+ * ```
+ *
+ * `GtkEntry` has a main node with the name entry. Depending on the properties
+ * of the entry, the style classes .read-only and .flat may appear. The style
+ * classes .warning and .error may also be used with entries.
+ *
+ * When the entry shows icons, it adds subnodes with the name image and the
+ * style class .left or .right, depending on where the icon appears.
+ *
+ * When the entry shows progress, it adds a subnode with the name progress.
+ * The node has the style class .pulse when the shown progress is pulsing.
+ *
+ * For all the subnodes added to the text node in various situations,
+ * see {@link Gtk.Text}.
+ *
+ * # GtkEntry as GtkBuildable
+ *
+ * The `GtkEntry` implementation of the `GtkBuildable` interface supports a
+ * custom `<attributes>` element, which supports any number of `<attribute>`
+ * elements. The `<attribute>` element has attributes named “name“, “value“,
+ * “start“ and “end“ and allows you to specify `PangoAttribute` values for
+ * this label.
+ *
+ * An example of a UI definition fragment specifying Pango attributes:
+ * ```xml
+ * <object class="GtkEntry">
+ *   <attributes>
+ *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
+ *     <attribute name="background" value="red" start="5" end="10"/>
+ *   </attributes>
+ * </object>
+ * ```
+ *
+ * The start and end attributes specify the range of characters to which the
+ * Pango attribute applies. If start and end are not specified, the attribute
+ * is applied to the whole text. Note that specifying ranges does not make much
+ * sense with translatable attributes. Use markup embedded in the translatable
+ * content instead.
+ *
+ * # Accessibility
+ *
+ * `GtkEntry` uses the {@link Gtk.AccessibleRole.text_box} role.
+ */
 export declare class Entry extends Widget {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
-    /**
-     * Creates a new entry.
-     */
+    /** Creates a new entry. */
     constructor();
-    /**
-     * Creates a new entry with the specified text buffer.
-     * @param buffer - The buffer to use for the new `GtkEntry`.
-     */
+    /** Creates a new entry with the specified text buffer. */
     static newWithBuffer(buffer: EntryBuffer): Entry;
-    /**
-     * Retrieves the value set by gtk_entry_set_activates_default().
-     */
+    /** Retrieves the value set by gtk_entry_set_activates_default(). */
     getActivatesDefault(): boolean;
     /**
      * Gets the value set by gtk_entry_set_alignment().
@@ -52,18 +132,11 @@ export declare class Entry extends Widget {
      * current  DND operation, or -1.
      */
     getCurrentIconDragSource(): number;
-    /**
-     * Gets the menu model set with gtk_entry_set_extra_menu().
-     */
+    /** Gets the menu model set with gtk_entry_set_extra_menu(). */
     getExtraMenu(): Gio.MenuModel | null;
-    /**
-     * Gets the value set by gtk_entry_set_has_frame().
-     */
+    /** Gets the value set by gtk_entry_set_has_frame(). */
     getHasFrame(): boolean;
-    /**
-     * Returns whether the icon is activatable.
-     * @param iconPos - Icon position
-     */
+    /** Returns whether the icon is activatable. */
     getIconActivatable(iconPos: EntryIconPosition): boolean;
     /**
      * Gets the area where entry’s icon at `icon_pos` is drawn.
@@ -75,8 +148,6 @@ export declare class Entry extends Widget {
      * position, `icon_area` is filled with zeros. Otherwise,
      * `icon_area` will be filled with the icon's allocation,
      * relative to `entry`'s allocation.
-     * @param iconPos - Icon position
-     * @param iconArea - Return location for the icon’s area
      */
     getIconArea(iconPos: EntryIconPosition, iconArea: Gdk.Rectangle): void;
     /**
@@ -86,8 +157,6 @@ export declare class Entry extends Widget {
      * top left corner. If `x`, `y` doesn’t lie inside an icon,
      * -1 is returned. This function is intended for use in a
      * {@link Gtk.Widget.:query-tooltip} signal handler.
-     * @param x - the x coordinate of the position to find, relative to `entry`
-     * @param y - the y coordinate of the position to find, relative to `entry`
      */
     getIconAtPos(x: number, y: number): number;
     /**
@@ -95,7 +164,6 @@ export declare class Entry extends Widget {
      *
      * %NULL will be returned if there is no icon or if the icon was
      * set by some other method (e.g., by `GdkPaintable` or icon name).
-     * @param iconPos - Icon position
      */
     getIconGicon(iconPos: EntryIconPosition): Gio.Icon | null;
     /**
@@ -103,20 +171,15 @@ export declare class Entry extends Widget {
      *
      * %NULL is returned if there is no icon or if the icon was set
      * by some other method (e.g., by `GdkPaintable` or gicon).
-     * @param iconPos - Icon position
      */
     getIconName(iconPos: EntryIconPosition): string | null;
     /**
      * Retrieves the `GdkPaintable` used for the icon.
      *
      * If no `GdkPaintable` was used for the icon, %NULL is returned.
-     * @param iconPos - Icon position
      */
     getIconPaintable(iconPos: EntryIconPosition): Gdk.Paintable | null;
-    /**
-     * Returns whether the icon appears sensitive or insensitive.
-     * @param iconPos - Icon position
-     */
+    /** Returns whether the icon appears sensitive or insensitive. */
     getIconSensitive(iconPos: EntryIconPosition): boolean;
     /**
      * Gets the type of representation being used by the icon
@@ -124,28 +187,21 @@ export declare class Entry extends Widget {
      *
      * If the icon has no image data, the return value will
      * be %GTK_IMAGE_EMPTY.
-     * @param iconPos - Icon position
      */
     getIconStorageType(iconPos: EntryIconPosition): ImageType;
     /**
      * Gets the contents of the tooltip on the icon at the specified
      * position in `entry`.
-     * @param iconPos - the icon position
      */
     getIconTooltipMarkup(iconPos: EntryIconPosition): string | null;
     /**
      * Gets the contents of the tooltip on the icon at the specified
      * position in `entry`.
-     * @param iconPos - the icon position
      */
     getIconTooltipText(iconPos: EntryIconPosition): string | null;
-    /**
-     * Gets the input hints of this `GtkEntry`.
-     */
+    /** Gets the input hints of this `GtkEntry`. */
     getInputHints(): InputHints;
-    /**
-     * Gets the input purpose of the `GtkEntry`.
-     */
+    /** Gets the input purpose of the `GtkEntry`. */
     getInputPurpose(): InputPurpose;
     /**
      * Retrieves the character displayed in place of the actual text
@@ -165,12 +221,9 @@ export declare class Entry extends Widget {
      * This greatly simplifies making accessible applications, because the icons
      * aren't focusable when using keyboard navigation. This is why Gtk recommends
      * to add the same action to the context menu.
-     * @param iconPos - either `GTK_ENTRY_ICON_PRIMARY` or `GTK_ENTRY_ICON_SECONDARY`
      */
     getMenuEntryIconText(iconPos: EntryIconPosition): string | null;
-    /**
-     * Gets whether the `GtkEntry` is in overwrite mode.
-     */
+    /** Gets whether the `GtkEntry` is in overwrite mode. */
     getOverwriteMode(): boolean;
     /**
      * Retrieves the text that will be displayed when `entry`
@@ -240,7 +293,6 @@ export declare class Entry extends Widget {
      *
      * This usually means that the dialog containing the entry will be closed,
      * since the default widget is usually one of the dialog buttons.
-     * @param setting - %TRUE to activate window’s default widget on Enter keypress
      */
     setActivatesDefault(setting: boolean): void;
     /**
@@ -250,7 +302,6 @@ export declare class Entry extends Widget {
      * the displayed text is shorter than the width of the entry.
      *
      * See also: {@link Gtk.Editable.xalign}
-     * @param xalign - The horizontal alignment, from 0 (left) to 1 (right).
      */
     setAlignment(xalign: number): void;
     /**
@@ -261,13 +312,11 @@ export declare class Entry extends Widget {
      * Since the attributes will be applied to text that changes
      * as the user types, it makes most sense to use attributes
      * with unlimited extent.
-     * @param attrs - a `PangoAttrList`
      */
     setAttributes(attrs: Pango.AttrList): void;
     /**
      * Set the `GtkEntryBuffer` object which holds the text for
      * this widget.
-     * @param buffer - a `GtkEntryBuffer`
      */
     setBuffer(buffer: EntryBuffer): void;
     /**
@@ -277,34 +326,22 @@ export declare class Entry extends Widget {
      * All further configuration of the completion mechanism is
      * done on `completion` using the `GtkEntryCompletion` API.
      * Completion is disabled if `completion` is set to %NULL.
-     * @param completion - The `GtkEntryCompletion`
      */
-    setCompletion(completion?: EntryCompletion): void;
+    setCompletion(completion?: EntryCompletion | null): void;
     /**
      * Sets a menu model to add when constructing
      * the context menu for `entry`.
-     * @param model - a `GMenuModel`
-     */
-    setExtraMenu(model?: Gio.MenuModel): void;
-    /**
-     * Sets whether the entry has a beveled frame around it.
-     * @param setting - new value
      */
+    setExtraMenu(model?: Gio.MenuModel | null): void;
+    /** Sets whether the entry has a beveled frame around it. */
     setHasFrame(setting: boolean): void;
-    /**
-     * Sets whether the icon is activatable.
-     * @param iconPos - Icon position
-     * @param activatable - %TRUE if the icon should be activatable
-     */
+    /** Sets whether the icon is activatable. */
     setIconActivatable(iconPos: EntryIconPosition, activatable: boolean): void;
     /**
      * Sets up the icon at the given position as drag source.
      *
      * This makes it so that GTK will start a drag
      * operation when the user clicks and drags the icon.
-     * @param iconPos - icon position
-     * @param provider - a `GdkContentProvider`
-     * @param actions - a bitmask of the allowed drag actions
      */
     setIconDragSource(iconPos: EntryIconPosition, provider: Gdk.ContentProvider, actions: Gdk.DragAction): void;
     /**
@@ -316,10 +353,8 @@ export declare class Entry extends Widget {
      *
      * If `icon` is %NULL, no icon will be shown in the
      * specified position.
-     * @param iconPos - The position at which to set the icon
-     * @param icon - The icon to set
      */
-    setIconFromGicon(iconPos: EntryIconPosition, icon?: Gio.Icon): void;
+    setIconFromGicon(iconPos: EntryIconPosition, icon?: Gio.Icon | null): void;
     /**
      * Sets the icon shown in the entry at the specified position
      * from the current icon theme.
@@ -329,23 +364,15 @@ export declare class Entry extends Widget {
      *
      * If `icon_name` is %NULL, no icon will be shown in the
      * specified position.
-     * @param iconPos - The position at which to set the icon
-     * @param iconName - An icon name
      */
-    setIconFromIconName(iconPos: EntryIconPosition, iconName?: string): void;
+    setIconFromIconName(iconPos: EntryIconPosition, iconName?: string | null): void;
     /**
      * Sets the icon shown in the specified position using a `GdkPaintable`.
      *
      * If `paintable` is %NULL, no icon will be shown in the specified position.
-     * @param iconPos - Icon position
-     * @param paintable - A `GdkPaintable`
-     */
-    setIconFromPaintable(iconPos: EntryIconPosition, paintable?: Gdk.Paintable): void;
-    /**
-     * Sets the sensitivity for the specified icon.
-     * @param iconPos - Icon position
-     * @param sensitive - Specifies whether the icon should appear
      */
+    setIconFromPaintable(iconPos: EntryIconPosition, paintable?: Gdk.Paintable | null): void;
+    /** Sets the sensitivity for the specified icon. */
     setIconSensitive(iconPos: EntryIconPosition, sensitive: boolean): void;
     /**
      * Sets `tooltip` as the contents of the tooltip for the icon at
@@ -357,10 +384,8 @@ export declare class Entry extends Widget {
      *
      * See also {@link Gtk.Widget.set_tooltip_markup} and
      * {@link Gtk.Entry.set_icon_tooltip_text}.
-     * @param iconPos - the icon position
-     * @param tooltip - the contents of the tooltip for the icon
      */
-    setIconTooltipMarkup(iconPos: EntryIconPosition, tooltip?: string): void;
+    setIconTooltipMarkup(iconPos: EntryIconPosition, tooltip?: string | null): void;
     /**
      * Sets `tooltip` as the contents of the tooltip for the icon
      * at the specified position.
@@ -379,20 +404,16 @@ export declare class Entry extends Widget {
      * {@link Gtk.Widget.has-tooltip} back to %TRUE, or
      * setting at least one non-empty tooltip on any icon
      * achieves the same result.
-     * @param iconPos - the icon position
-     * @param tooltip - the contents of the tooltip for the icon
      */
-    setIconTooltipText(iconPos: EntryIconPosition, tooltip?: string): void;
+    setIconTooltipText(iconPos: EntryIconPosition, tooltip?: string | null): void;
     /**
      * Set additional hints which allow input methods to
      * fine-tune their behavior.
-     * @param hints - the hints
      */
     setInputHints(hints: InputHints): void;
     /**
      * Sets the input purpose which can be used by input methods
      * to adjust their behavior.
-     * @param purpose - the purpose
      */
     setInputPurpose(purpose: InputPurpose): void;
     /**
@@ -406,7 +427,6 @@ export declare class Entry extends Widget {
      * the current font. If you set the invisible char to 0, then
      * the user will get no feedback at all; there will be no text
      * on the screen as they type.
-     * @param ch - a Unicode character
      */
     setInvisibleChar(ch: number): void;
     /**
@@ -417,7 +437,6 @@ export declare class Entry extends Widget {
      *
      * This is equivalent to getting `entry`'s `GtkEntryBuffer` and
      * calling {@link Gtk.EntryBuffer.set_max_length} on it.
-     * @param max - the maximum length of the entry, or 0 for no maximum.
      */
     setMaxLength(max: number): void;
     /**
@@ -427,29 +446,22 @@ export declare class Entry extends Widget {
      * This greatly simplifies making accessible applications, because the icons
      * aren't focusable when using keyboard navigation. This is why Gtk recommends
      * to add the same action to the context menu.
-     * @param iconPos - either `GTK_ENTRY_ICON_PRIMARY` or `GTK_ENTRY_ICON_SECONDARY`
-     * @param text - the text used for the menu item in the context menu, or NULL to not add a menu item.
      */
     setMenuEntryIconText(iconPos: EntryIconPosition, text: string): void;
-    /**
-     * Sets whether the text is overwritten when typing in the `GtkEntry`.
-     * @param overwrite - new value
-     */
+    /** Sets whether the text is overwritten when typing in the `GtkEntry`. */
     setOverwriteMode(overwrite: boolean): void;
     /**
      * Sets text to be displayed in `entry` when it is empty.
      *
      * This can be used to give a visual hint of the expected
      * contents of the `GtkEntry`.
-     * @param text - a string to be displayed when `entry` is empty and unfocused
      */
-    setPlaceholderText(text?: string): void;
+    setPlaceholderText(text?: string | null): void;
     /**
      * Causes the entry’s progress indicator to “fill in” the given
      * fraction of the bar.
      *
      * The fraction should be between 0.0 and 1.0, inclusive.
-     * @param fraction - fraction of the task that’s been completed
      */
     setProgressFraction(fraction: number): void;
     /**
@@ -458,16 +470,14 @@ export declare class Entry extends Widget {
      *
      * Use {@link Gtk.Entry.progress_pulse} to pulse
      * the progress.
-     * @param fraction - fraction between 0.0 and 1.0
      */
     setProgressPulseStep(fraction: number): void;
     /**
      * Sets a `PangoTabArray`.
      *
      * The tabstops in the array are applied to the entry text.
-     * @param tabs - a `PangoTabArray`
      */
-    setTabs(tabs?: Pango.TabArray): void;
+    setTabs(tabs?: Pango.TabArray | null): void;
     /**
      * Sets whether the contents of the entry are visible or not.
      *
@@ -483,7 +493,6 @@ export declare class Entry extends Widget {
      * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
      * inform input methods about the purpose of this entry,
      * in addition to setting visibility to %FALSE.
-     * @param visible - %TRUE if the contents of the entry are displayed as plaintext
      */
     setVisibility(visible: boolean): void;
     /**
@@ -491,13 +500,9 @@ export declare class Entry extends Widget {
      * is used again. See {@link Gtk.Entry.set_invisible_char}.
      */
     unsetInvisibleChar(): void;
-    /**
-     * Emits the `GtkCellEditable::editing-done` signal.
-     */
+    /** Emits the `GtkCellEditable::editing-done` signal. */
     editingDone(): void;
-    /**
-     * Emits the `GtkCellEditable::remove-widget` signal.
-     */
+    /** Emits the `GtkCellEditable::remove-widget` signal. */
     removeWidget(): void;
     /**
      * Begins editing on a `cell_editable`.
@@ -510,9 +515,8 @@ export declare class Entry extends Widget {
      *
      * Note that the `cell_editable` is created on-demand for the current edit; its
      * lifetime is temporary and does not persist across other edits and/or cells.
-     * @param event - The `GdkEvent` that began the editing process, or
      */
-    startEditing(event?: Gdk.Event): void;
+    startEditing(event?: Gdk.Event | null): void;
     /**
      * Retrieves the accessible platform state from the editable delegate.
      *
@@ -546,7 +550,6 @@ export declare class Entry extends Widget {
      * So, if you can't ensure the direct child condition, you should give the
      * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
      * change your tree to allow this function to work.
-     * @param state - what kind of accessible state to retrieve
      */
     delegateGetAccessiblePlatformState(state: AccessiblePlatformState): boolean;
     /**
@@ -564,8 +567,6 @@ export declare class Entry extends Widget {
      * the end of the text.
      *
      * Note that the positions are specified in characters, not bytes.
-     * @param startPos - start position
-     * @param endPos - end position
      */
     deleteText(startPos: number, endPos: number): void;
     /**
@@ -584,8 +585,6 @@ export declare class Entry extends Widget {
      * the end of the text.
      *
      * Note that positions are specified in characters, not bytes.
-     * @param startPos - start of text
-     * @param endPos - end of text
      */
     getChars(startPos: number, endPos: number): string;
     /**
@@ -595,17 +594,11 @@ export declare class Entry extends Widget {
      * Typically, the delegate is a {@link Gtk.Text} widget.
      */
     getDelegate(): Editable | null;
-    /**
-     * Retrieves whether `editable` is editable.
-     */
+    /** Retrieves whether `editable` is editable. */
     getEditable(): boolean;
-    /**
-     * Gets if undo/redo actions are enabled for `editable`
-     */
+    /** Gets if undo/redo actions are enabled for `editable` */
     getEnableUndo(): boolean;
-    /**
-     * Retrieves the desired maximum width of `editable`, in characters.
-     */
+    /** Retrieves the desired maximum width of `editable`, in characters. */
     getMaxWidthChars(): number;
     /**
      * Retrieves the current position of the cursor relative
@@ -622,10 +615,8 @@ export declare class Entry extends Widget {
      * and %FALSE will be returned.
      *
      * Note that positions are specified in characters, not bytes.
-     * @param startPos - location to store the starting position
-     * @param endPos - location to store the end position
      */
-    getSelectionBounds(startPos?: Ref<number>, endPos?: Ref<number>): boolean;
+    getSelectionBounds(startPos?: Ref<number> | null, endPos?: Ref<number> | null): boolean;
     /**
      * Retrieves the contents of `editable`.
      *
@@ -654,9 +645,6 @@ export declare class Entry extends Widget {
      * Note that the position is in characters, not in bytes.
      * The function updates `position` to point after the newly
      * inserted text.
-     * @param text - the text to insert
-     * @param length - the length of the text in bytes, or -1
-     * @param position - location of the position text will be inserted at
      */
     insertText(text: string, length: number, position: Ref<number>): void;
     /**
@@ -668,14 +656,9 @@ export declare class Entry extends Widget {
      * `start_pos` to  the end of the text.
      *
      * Note that positions are specified in characters, not bytes.
-     * @param startPos - start of region
-     * @param endPos - end of region
      */
     selectRegion(startPos: number, endPos: number): void;
-    /**
-     * Determines if the user can edit the text in the editable widget.
-     * @param isEditable - %TRUE if the user is allowed to edit the text
-     */
+    /** Determines if the user can edit the text in the editable widget. */
     setEditable(isEditable: boolean): void;
     /**
      * If enabled, changes to `editable` will be saved for undo/redo
@@ -684,13 +667,9 @@ export declare class Entry extends Widget {
      * This results in an additional copy of text changes and are not
      * stored in secure memory. As such, undo is forcefully disabled
      * when {@link Gtk.Text.visibility} is set to %FALSE.
-     * @param enableUndo - if undo/redo should be enabled
      */
     setEnableUndo(enableUndo: boolean): void;
-    /**
-     * Sets the desired maximum width in characters of `editable`.
-     * @param nChars - the new desired maximum width, in characters
-     */
+    /** Sets the desired maximum width in characters of `editable`. */
     setMaxWidthChars(nChars: number): void;
     /**
      * Sets the cursor position in the editable to the given value.
@@ -700,14 +679,12 @@ export declare class Entry extends Widget {
      * or equal to the number of characters in the editable. A value of -1
      * indicates that the position should be set after the last character
      * of the editable. Note that `position` is in characters, not in bytes.
-     * @param position - the position of the cursor
      */
     setPosition(position: number): void;
     /**
      * Sets the text in the editable to the given value.
      *
      * This is replacing the current contents.
-     * @param text - the text to set
      */
     setText(text: string): void;
     /**
@@ -717,7 +694,6 @@ export declare class Entry extends Widget {
      * Note that it changes the size request, the size can still
      * be affected by how you pack the widget into containers.
      * If `n_chars` is -1, the size reverts to the default size.
-     * @param nChars - width in chars
      */
     setWidthChars(nChars: number): void;
     connect(signal: "activate", handler: (self: Entry) => void, after?: boolean): number;
@@ -727,20 +703,6 @@ export declare class Entry extends Widget {
     connect(signal: "remove-widget", handler: (self: Entry) => void, after?: boolean): number;
     connect(signal: "changed", handler: (self: Entry) => void, after?: boolean): number;
     connect(signal: "delete-text", handler: (self: Entry, startPos: number, endPos: number) => void, after?: boolean): number;
-    connect(signal: "insert-text", handler: (self: Entry, text: string, length: number, position: number) => void, after?: boolean): number;
-    connect(signal: "destroy", handler: (self: Entry) => void, after?: boolean): number;
-    connect(signal: "direction-changed", handler: (self: Entry, previousDirection: TextDirection) => void, after?: boolean): number;
-    connect(signal: "hide", handler: (self: Entry) => void, after?: boolean): number;
-    connect(signal: "keynav-failed", handler: (self: Entry, direction: DirectionType) => boolean, after?: boolean): number;
-    connect(signal: "map", handler: (self: Entry) => void, after?: boolean): number;
-    connect(signal: "mnemonic-activate", handler: (self: Entry, groupCycling: boolean) => boolean, after?: boolean): number;
-    connect(signal: "move-focus", handler: (self: Entry, direction: DirectionType) => void, after?: boolean): number;
-    connect(signal: "query-tooltip", handler: (self: Entry, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
-    connect(signal: "realize", handler: (self: Entry) => void, after?: boolean): number;
-    connect(signal: "show", handler: (self: Entry) => void, after?: boolean): number;
-    connect(signal: "state-flags-changed", handler: (self: Entry, flags: StateFlags) => void, after?: boolean): number;
-    connect(signal: "unmap", handler: (self: Entry) => void, after?: boolean): number;
-    connect(signal: "unrealize", handler: (self: Entry) => void, after?: boolean): number;
-    connect(signal: "notify", handler: (self: Entry, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: "insert-text", handler: (self: Entry, text: string, length: number, position: Ref<number>) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }