@ringozz/godot 0.1.0

package/gen/classes/TextEdit.ts

@@ -0,0 +1,1458 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { Callable, GodotArray, PackedInt32Array, PackedStringArray, Signal, Variant } from '../heap-types/index.ts';
+import type { Color, Rect2i, Vector2, Vector2i } from '../value-types/index.ts';
+import type { TextDirection } from './Control.ts';
+import type { HScrollBar } from './HScrollBar.ts';
+import type { PopupMenu } from './PopupMenu.ts';
+import type { SyntaxHighlighter } from './SyntaxHighlighter.ts';
+import type { AutowrapMode, StructuredTextParser } from './TextServer.ts';
+import type { Texture2D } from './Texture2D.ts';
+import type { VScrollBar } from './VScrollBar.ts';
+
+/**
+ * A multiline text editor. It also has limited facilities for editing code, such as syntax highlighting support. For more advanced facilities for editing code, see {@link CodeEdit}.
+ * While entering text, it is possible to insert special characters using Unicode, OEM or Windows alt codes:
+ * - To enter Unicode codepoints, hold `Alt` and type the codepoint on the numpad. For example, to enter the character `á` (U+00E1), hold `Alt` and type `+E1` on the numpad (the leading zeroes can be omitted).
+ * - To enter OEM codepoints, hold `Alt` and type the code on the numpad. For example, to enter the character `á` (OEM 160), hold `Alt` and type `160` on the numpad.
+ * - To enter Windows codepoints, hold `Alt` and type the code on the numpad. For example, to enter the character `á` (Windows 0225), hold `Alt` and type `0`, `2`, `2`, `5` on the numpad. The leading zero here must **not** be omitted, as this is how Windows codepoints are distinguished from OEM codepoints.
+ * **Note:** Most viewport, caret, and edit methods contain a `caret_index` argument for {@link caretMultiple} support. The argument should be one of the following: `-1` for all carets, `0` for the main caret, or greater than `0` for secondary carets in the order they were created.
+ * **Note:** When holding down `Alt`, the vertical scroll wheel will scroll 5 times as fast as it would normally do. This also works in the Godot script editor.
+ */
+export class TextEdit extends Control {
+    constructor(name = 767) { super(name); }
+
+    /**
+     * Returns `true` if the user has text in the [Input Method Editor](https://en.wikipedia.org/wiki/Input_method) (IME).
+     */
+    hasImeText(): boolean { return _C(this, 7404) as boolean; }
+
+    /**
+     * Closes the [Input Method Editor](https://en.wikipedia.org/wiki/Input_method) (IME) if it is open. Any text in the IME will be lost.
+     */
+    cancelIme(): void { _C(this, 2023); }
+
+    /**
+     * Applies text from the [Input Method Editor](https://en.wikipedia.org/wiki/Input_method) (IME) to each caret and closes the IME if it is open.
+     */
+    applyIme(): void { _C(this, 1532); }
+
+    /**
+     * Sets the tab size for the {@link TextEdit} to use.
+     */
+    setTabSize(size: number): void { _C(this, 12980, size); }
+
+    /**
+     * Returns the {@link TextEdit}'s' tab size.
+     */
+    getTabSize(): number { return _C(this, 6682) as number; }
+
+    /**
+     * If `true`, enables overtype mode. In this mode, typing overrides existing text instead of inserting text. The {@link ProjectSettings.input/uiTextToggleInsertMode} action toggles overtype mode. See {@link isOvertypeModeEnabled}.
+     */
+    setOvertypeModeEnabled(enabled: boolean): void { _C(this, 12232, enabled); }
+
+    /**
+     * Returns `true` if overtype mode is enabled. See {@link setOvertypeModeEnabled}.
+     */
+    isOvertypeModeEnabled(): boolean { return _C(this, 8162) as boolean; }
+
+    /**
+     * Performs a full reset of {@link TextEdit}, including undo history.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns the number of lines in the text.
+     */
+    getLineCount(): number { return _C(this, 5355) as number; }
+
+    /**
+     * Sets the text for a specific `line`.
+     * Carets on the line will attempt to keep their visual x position.
+     */
+    setLine(line: number, newText: string): void { _C(this, 11911, line, newText); }
+
+    /**
+     * Returns the text of a specific line.
+     */
+    getLine(line: number): string { return _C(this, 5351, line) as string; }
+
+    /**
+     * Returns line text as it is currently displayed, including IME composition string.
+     */
+    getLineWithIme(line: number): string { return _C(this, 5377, line) as string; }
+
+    /**
+     * Returns the width in pixels of the `wrapIndex` on `line`.
+     */
+    getLineWidth(line: number, wrapIndex?: number /* = -1 */): number { return _C(this, 5376, line, wrapIndex) as number; }
+
+    /**
+     * Returns the maximum value of the line height among all lines.
+     * **Note:** The return value is influenced by {@link line_spacing} and {@link font_size}. And it will not be less than `1`.
+     */
+    getLineHeight(): number { return _C(this, 5362) as number; }
+
+    /**
+     * Returns the indent level of the given line. This is the number of spaces and tabs at the beginning of the line, with the tabs taking the tab size into account (see {@link getTabSize}).
+     */
+    getIndentLevel(line: number): number { return _C(this, 5083, line) as number; }
+
+    /**
+     * Returns the first column containing a non-whitespace character on the given line. If there is only whitespace, returns the number of characters.
+     */
+    getFirstNonWhitespaceColumn(line: number): number { return _C(this, 4794, line) as number; }
+
+    /**
+     * Swaps the two lines. Carets will be swapped with the lines.
+     */
+    swapLines(fromLine: number, toLine: number): void { _C(this, 14053, fromLine, toLine); }
+
+    /**
+     * Inserts a new line with `text` at `line`.
+     */
+    insertLineAt(line: number, text: string): void { _C(this, 7634, line, text); }
+
+    /**
+     * Removes the line of text at `line`. Carets on this line will attempt to match their previous visual x position.
+     * If `moveCaretsDown` is `true` carets will move to the next line down, otherwise carets will move up.
+     */
+    removeLineAt(line: number, moveCaretsDown?: boolean /* = true */): void { _C(this, 9930, line, moveCaretsDown); }
+
+    /**
+     * Insert the specified text at the caret position.
+     */
+    insertTextAtCaret(text: string, caretIndex?: number /* = -1 */): void { _C(this, 7636, text, caretIndex); }
+
+    /**
+     * Inserts the `text` at `line` and `column`.
+     * If `beforeSelectionBegin` is `true`, carets and selections that begin at `line` and `column` will moved to the end of the inserted text, along with all carets after it.
+     * If `beforeSelectionEnd` is `true`, selections that end at `line` and `column` will be extended to the end of the inserted text. These parameters can be used to insert text inside of or outside of selections.
+     */
+    insertText(text: string, line: number, column: number, beforeSelectionBegin?: boolean /* = true */, beforeSelectionEnd?: boolean /* = false */): void { _C(this, 7635, text, line, column, beforeSelectionBegin, beforeSelectionEnd); }
+
+    /**
+     * Removes text between the given positions.
+     */
+    removeText(fromLine: number, fromColumn: number, toLine: number, toColumn: number): void { _C(this, 9968, fromLine, fromColumn, toLine, toColumn); }
+
+    /**
+     * Returns the last unhidden line in the entire {@link TextEdit}.
+     */
+    getLastUnhiddenLine(): number { return _C(this, 5310) as number; }
+
+    /**
+     * Returns the count to the next visible line from `line` to `line + visible_amount`. Can also count backwards. For example if a {@link TextEdit} has 5 lines with lines 2 and 3 hidden, calling this with `line = 1, visible_amount = 1` would return 3.
+     */
+    getNextVisibleLineOffsetFrom(line: number, visibleAmount: number): number { return _C(this, 5635, line, visibleAmount) as number; }
+
+    /**
+     * Similar to {@link getNextVisibleLineOffsetFrom}, but takes into account the line wrap indexes. In the returned vector, `x` is the line, `y` is the wrap index.
+     */
+    getNextVisibleLineIndexOffsetFrom(line: number, wrapIndex: number, visibleAmount: number): Vector2i { return _C(this, 5634, line, wrapIndex, visibleAmount) as Vector2i; }
+
+    /**
+     * Called when the user presses the backspace key. Can be overridden with {@link _backspace}.
+     */
+    backspace(caretIndex?: number /* = -1 */): void { _C(this, 1706, caretIndex); }
+
+    /**
+     * Cut's the current selection. Can be overridden with {@link _cut}.
+     */
+    cut(caretIndex?: number /* = -1 */): void { _C(this, 2636, caretIndex); }
+
+    /**
+     * Copies the current text selection. Can be overridden with {@link _copy}.
+     */
+    copy(caretIndex?: number /* = -1 */): void { _C(this, 2486, caretIndex); }
+
+    /**
+     * Paste at the current location. Can be overridden with {@link _paste}.
+     */
+    paste(caretIndex?: number /* = -1 */): void { _C(this, 9346, caretIndex); }
+
+    /**
+     * Pastes the primary clipboard.
+     */
+    pastePrimaryClipboard(caretIndex?: number /* = -1 */): void { _C(this, 9348, caretIndex); }
+
+    /**
+     * Starts an action, will end the current action if `action` is different.
+     * An action will also end after a call to {@link endAction}, after {@link ProjectSettings.gui/timers/textEditIdleDetectSec} is triggered or a new undoable step outside the {@link startAction} and {@link endAction} calls.
+     */
+    startAction(action: EditAction): void { _C(this, 13830, action); }
+
+    /**
+     * Marks the end of steps in the current action started with {@link startAction}.
+     */
+    endAction(): void { _C(this, 3094); }
+
+    /**
+     * Starts a multipart edit. All edits will be treated as one action until {@link endComplexOperation} is called.
+     */
+    beginComplexOperation(): void { _C(this, 1748); }
+
+    /**
+     * Ends a multipart edit, started with {@link beginComplexOperation}. If called outside a complex operation, the current operation is pushed onto the undo/redo stack.
+     */
+    endComplexOperation(): void { _C(this, 3097); }
+
+    /**
+     * Returns `true` if an "undo" action is available.
+     */
+    hasUndo(): boolean { return _C(this, 7479) as boolean; }
+
+    /**
+     * Returns `true` if a "redo" action is available.
+     */
+    hasRedo(): boolean { return _C(this, 7434) as boolean; }
+
+    /**
+     * Perform undo operation.
+     */
+    undo(): void { _C(this, 14462); }
+
+    /**
+     * Perform redo operation.
+     */
+    redo(): void { _C(this, 9770); }
+
+    /**
+     * Clears the undo history.
+     */
+    clearUndoHistory(): void { _C(this, 2308); }
+
+    /**
+     * Tag the current version as saved.
+     */
+    tagSavedVersion(): void { _C(this, 14111); }
+
+    /**
+     * Returns the current version of the {@link TextEdit}. The version is a count of recorded operations by the undo/redo history.
+     */
+    getVersion(): number { return _C(this, 7041) as number; }
+
+    /**
+     * Returns the last tagged saved version from {@link tagSavedVersion}.
+     */
+    getSavedVersion(): number { return _C(this, 6235) as number; }
+
+    /**
+     * Sets the search text. See {@link setSearchFlags}.
+     */
+    setSearchText(searchText: string): void { _C(this, 12667, searchText); }
+
+    /**
+     * Sets the search `flags`. This is used with {@link setSearchText} to highlight occurrences of the searched text. Search flags can be specified from the {@link SearchFlags} enum.
+     */
+    setSearchFlags(flags: number /* uint32 */): void { _C(this, 12666, flags); }
+
+    /**
+     * Perform a search inside the text. Search flags can be specified in the {@link SearchFlags} enum.
+     * In the returned vector, `x` is the column, `y` is the line. If no results are found, both are equal to `-1`.
+     *
+     *
+     * ```gdscript
+     *
+     * var result = search("print", SEARCH_WHOLE_WORDS, 0, 0)
+     * if result.x != -1:
+     * 	# Result found.
+     * 	var line_number = result.y
+     * 	var column_number = result.x
+     *
+     * ```
+     */
+    search(text: string, flags: number /* uint32 */, fromLine: number, fromColumn: number): Vector2i { return _C(this, 10324, text, flags, fromLine, fromColumn) as Vector2i; }
+
+    /**
+     * Provide custom tooltip text. The callback method must take the following args: `hovered_word: String`.
+     */
+    setTooltipRequestFunc(callback: Callable): void { _C(this, 13114, callback); }
+
+    /**
+     * Returns the local mouse position adjusted for the text direction.
+     */
+    getLocalMousePos(): Vector2 { return _C(this, 5396) as Vector2; }
+
+    /**
+     * Returns the word at `position`.
+     */
+    getWordAtPos(position: Vector2): string { return _C(this, 7158, position) as string; }
+
+    /**
+     * Returns the line and column at the given position. In the returned vector, `x` is the column and `y` is the line.
+     * If `clampLine` is `false` and `position` is below the last line, `Vector2i(-1, -1)` is returned.
+     * If `clampColumn` is `false` and `position` is outside the column range of the line, `Vector2i(-1, -1)` is returned.
+     */
+    getLineColumnAtPos(position: Vector2i, clampLine?: boolean /* = true */, clampColumn?: boolean /* = true */): Vector2i { return _C(this, 5354, position, clampLine, clampColumn) as Vector2i; }
+
+    /**
+     * Returns the local position for the given `line` and `column`. If `x` or `y` of the returned vector equal `-1`, the position is outside of the viewable area of the control.
+     * **Note:** The Y position corresponds to the bottom side of the line. Use {@link getRectAtLineColumn} to get the top side position.
+     */
+    getPosAtLineColumn(line: number, column: number): Vector2i { return _C(this, 5970, line, column) as Vector2i; }
+
+    /**
+     * Returns the local position and size for the grapheme at the given `line` and `column`. If `x` or `y` position of the returned rect equal `-1`, the position is outside of the viewable area of the control.
+     * **Note:** The Y position of the returned rect corresponds to the top side of the line, unlike {@link getPosAtLineColumn} which returns the bottom side.
+     */
+    getRectAtLineColumn(line: number, column: number): Rect2i { return _C(this, 6093, line, column) as Rect2i; }
+
+    /**
+     * Returns the equivalent minimap line at `position`.
+     */
+    getMinimapLineAtPos(position: Vector2i): number { return _C(this, 5548, position) as number; }
+
+    /**
+     * Returns `true` if the user is dragging their mouse for scrolling, selecting, or text dragging.
+     */
+    isDraggingCursor(): boolean { return _C(this, 7900) as boolean; }
+
+    /**
+     * Returns `true` if the mouse is over a selection. If `edges` is `true`, the edges are considered part of the selection.
+     */
+    isMouseOverSelection(edges: boolean, caretIndex?: number /* = -1 */): boolean { return _C(this, 8117, edges, caretIndex) as boolean; }
+
+    /**
+     * Adds a new caret at the given location. Returns the index of the new caret, or `-1` if the location is invalid.
+     */
+    addCaret(line: number, column: number): number { return _C(this, 1192, line, column) as number; }
+
+    /**
+     * Removes the given caret index.
+     * **Note:** This can result in adjustment of all other caret indices.
+     */
+    removeCaret(caret: number): void { _C(this, 9894, caret); }
+
+    /**
+     * Removes all additional carets.
+     */
+    removeSecondaryCarets(): void { _C(this, 9955); }
+
+    /**
+     * Returns the number of carets in this {@link TextEdit}.
+     */
+    getCaretCount(): number { return _C(this, 4089) as number; }
+
+    /**
+     * Adds an additional caret above or below every caret. If `below` is `true` the new caret will be added below and above otherwise.
+     */
+    addCaretAtCarets(below: boolean): void { _C(this, 1193, below); }
+
+    /**
+     * Returns the carets sorted by selection beginning from lowest line and column to highest (from top to bottom of text).
+     * If `includeIgnoredCarets` is `false`, carets from {@link multicaretEditIgnoreCaret} will be ignored.
+     */
+    getSortedCarets(includeIgnoredCarets?: boolean /* = false */): PackedInt32Array { return _C(this, 6453, includeIgnoredCarets) as PackedInt32Array; }
+
+    /**
+     * Collapse all carets in the given range to the `fromLine` and `fromColumn` position.
+     * `inclusive` applies to both ends.
+     * If {@link isInMulitcaretEdit} is `true`, carets that are collapsed will be `true` for {@link multicaretEditIgnoreCaret}.
+     * {@link mergeOverlappingCarets} will be called if any carets were collapsed.
+     */
+    collapseCarets(fromLine: number, fromColumn: number, toLine: number, toColumn: number, inclusive?: boolean /* = false */): void { _C(this, 2342, fromLine, fromColumn, toLine, toColumn, inclusive); }
+
+    /**
+     * Merges any overlapping carets. Will favor the newest caret, or the caret with a selection.
+     * If {@link isInMulitcaretEdit} is `true`, the merge will be queued to happen at the end of the multicaret edit. See {@link beginMulticaretEdit} and {@link endMulticaretEdit}.
+     * **Note:** This is not called when a caret changes position but after certain actions, so it is possible to get into a state where carets overlap.
+     */
+    mergeOverlappingCarets(): void { _C(this, 8853); }
+
+    /**
+     * Starts an edit for multiple carets. The edit must be ended with {@link endMulticaretEdit}. Multicaret edits can be used to edit text at multiple carets and delay merging the carets until the end, so the caret indexes aren't affected immediately. {@link beginMulticaretEdit} and {@link endMulticaretEdit} can be nested, and the merge will happen at the last {@link endMulticaretEdit}.
+     *
+     * ```text
+     *
+     * begin_complex_operation()
+     * begin_multicaret_edit()
+     * for i in range(get_caret_count()):
+     * 	if multicaret_edit_ignore_caret(i):
+     * 		continue
+     * 	# Logic here.
+     * end_multicaret_edit()
+     * end_complex_operation()
+     *
+     * ```
+     */
+    beginMulticaretEdit(): void { _C(this, 1750); }
+
+    /**
+     * Ends an edit for multiple carets, that was started with {@link beginMulticaretEdit}. If this was the last {@link endMulticaretEdit} and {@link mergeOverlappingCarets} was called, carets will be merged.
+     */
+    endMulticaretEdit(): void { _C(this, 3100); }
+
+    /**
+     * Returns `true` if a {@link beginMulticaretEdit} has been called and {@link endMulticaretEdit} has not yet been called.
+     */
+    isInMulitcaretEdit(): boolean { return _C(this, 8016) as boolean; }
+
+    /**
+     * Returns `true` if the given `caretIndex` should be ignored as part of a multicaret edit. See {@link beginMulticaretEdit} and {@link endMulticaretEdit}. Carets that should be ignored are ones that were part of removed text and will likely be merged at the end of the edit, or carets that were added during the edit.
+     * It is recommended to `continue` within a loop iterating on multiple carets if a caret should be ignored.
+     */
+    multicaretEditIgnoreCaret(caretIndex: number): boolean { return _C(this, 9012, caretIndex) as boolean; }
+
+    /**
+     * Returns `true` if the caret is visible, `false` otherwise. A caret will be considered hidden if it is outside the scrollable area when scrolling is enabled.
+     * **Note:** {@link isCaretVisible} does not account for a caret being off-screen if it is still within the scrollable area. It will return `true` even if the caret is off-screen as long as it meets {@link TextEdit}'s own conditions for being visible. This includes uses of {@link scrollFitContentWidth} and {@link scrollFitContentHeight} that cause the {@link TextEdit} to expand beyond the viewport's bounds.
+     * **Note:** This method does *not* guarantee an accurate visibility check immediately after setting the caret position. The correct value may only be available in the next frame after the {@link TextEdit} has finished drawing. This also applies to any operation that causes the {@link TextEdit} to change in size.
+     */
+    isCaretVisible(caretIndex?: number /* = 0 */): boolean { return _C(this, 7822, caretIndex) as boolean; }
+
+    /**
+     * Returns the caret pixel draw position.
+     */
+    getCaretDrawPos(caretIndex?: number /* = 0 */): Vector2 { return _C(this, 4090, caretIndex) as Vector2; }
+
+    /**
+     * Moves the caret to the specified `line` index. The caret column will be moved to the same visual position it was at the last time {@link setCaretColumn} was called, or clamped to the end of the line.
+     * If `adjustViewport` is `true`, the viewport will center at the caret position after the move occurs.
+     * If `canBeHidden` is `true`, the specified `line` can be hidden.
+     * If `wrapIndex` is `-1`, the caret column will be clamped to the `line`'s length. If `wrapIndex` is greater than `-1`, the column will be moved to attempt to match the visual x position on the line's `wrapIndex` to the position from the last time {@link setCaretColumn} was called.
+     * **Note:** If supporting multiple carets this will not check for any overlap. See {@link mergeOverlappingCarets}.
+     */
+    setCaretLine(line: number, adjustViewport?: boolean /* = true */, canBeHidden?: boolean /* = true */, wrapIndex?: number /* = 0 */, caretIndex?: number /* = 0 */): void { _C(this, 10806, line, adjustViewport, canBeHidden, wrapIndex, caretIndex); }
+
+    /**
+     * Returns the line the editing caret is on.
+     */
+    getCaretLine(caretIndex?: number /* = 0 */): number { return _C(this, 4092, caretIndex) as number; }
+
+    /**
+     * Moves the caret to the specified `column` index.
+     * If `adjustViewport` is `true`, the viewport will center at the caret position after the move occurs.
+     * **Note:** If supporting multiple carets this will not check for any overlap. See {@link mergeOverlappingCarets}.
+     */
+    setCaretColumn(column: number, adjustViewport?: boolean /* = true */, caretIndex?: number /* = 0 */): void { _C(this, 10804, column, adjustViewport, caretIndex); }
+
+    /**
+     * Returns the column the editing caret is at.
+     */
+    getCaretColumn(caretIndex?: number /* = 0 */): number { return _C(this, 4088, caretIndex) as number; }
+
+    /**
+     * Returns the correct column at the end of a composite character like ❤️‍🩹 (mending heart; Unicode: `U+2764 U+FE0F U+200D U+1FA79`) which is comprised of more than one Unicode code point, if the caret is at the start of the composite character. Also returns the correct column with the caret at mid grapheme and for non-composite characters.
+     * **Note:** To check at caret location use `get_next_composite_character_column(get_caret_line(), get_caret_column())`
+     */
+    getNextCompositeCharacterColumn(line: number, column: number): number { return _C(this, 5624, line, column) as number; }
+
+    /**
+     * Returns the correct column at the start of a composite character like ❤️‍🩹 (mending heart; Unicode: `U+2764 U+FE0F U+200D U+1FA79`) which is comprised of more than one Unicode code point, if the caret is at the end of the composite character. Also returns the correct column with the caret at mid grapheme and for non-composite characters.
+     * **Note:** To check at caret location use `get_previous_composite_character_column(get_caret_line(), get_caret_column())`
+     */
+    getPreviousCompositeCharacterColumn(line: number, column: number): number { return _C(this, 6002, line, column) as number; }
+
+    /**
+     * Returns the wrap index the editing caret is on.
+     */
+    getCaretWrapIndex(caretIndex?: number /* = 0 */): number { return _C(this, 4094, caretIndex) as number; }
+
+    /**
+     * Returns a {@link String} text with the word under the caret's location.
+     */
+    getWordUnderCaret(caretIndex?: number /* = -1 */): string { return _C(this, 7159, caretIndex) as string; }
+
+    /**
+     * Sets the current selection mode.
+     */
+    setSelectionMode(mode: SelectionMode): void { _C(this, 12691, mode); }
+
+    /**
+     * Returns the current selection mode.
+     */
+    getSelectionMode(): SelectionMode { return _C(this, 6337) as SelectionMode; }
+
+    /**
+     * Select all the text.
+     * If {@link selectingEnabled} is `false`, no selection will occur.
+     */
+    selectAll(): void { _C(this, 10354); }
+
+    /**
+     * Selects the word under the caret.
+     */
+    selectWordUnderCaret(caretIndex?: number /* = -1 */): void { _C(this, 10360, caretIndex); }
+
+    /**
+     * Adds a selection and a caret for the next occurrence of the current selection. If there is no active selection, selects word under caret.
+     */
+    addSelectionForNextOccurrence(): void { _C(this, 1285); }
+
+    /**
+     * Moves a selection and a caret for the next occurrence of the current selection. If there is no active selection, moves to the next occurrence of the word under caret.
+     */
+    skipSelectionForNextOccurrence(): void { _C(this, 13637); }
+
+    /**
+     * Selects text from `originLine` and `originColumn` to `caretLine` and `caretColumn` for the given `caretIndex`. This moves the selection origin and the caret. If the positions are the same, the selection will be deselected.
+     * If {@link selectingEnabled} is `false`, no selection will occur.
+     * **Note:** If supporting multiple carets this will not check for any overlap. See {@link mergeOverlappingCarets}.
+     */
+    select(originLine: number, originColumn: number, caretLine: number, caretColumn: number, caretIndex?: number /* = 0 */): void { _C(this, 10353, originLine, originColumn, caretLine, caretColumn, caretIndex); }
+
+    /**
+     * Returns `true` if the user has selected text.
+     */
+    hasSelection(caretIndex?: number /* = -1 */): boolean { return _C(this, 7444, caretIndex) as boolean; }
+
+    /**
+     * Returns the text inside the selection of a caret, or all the carets if `caretIndex` is its default value `-1`.
+     */
+    getSelectedText(caretIndex?: number /* = -1 */): string { return _C(this, 6329, caretIndex) as string; }
+
+    /**
+     * Returns the caret index of the selection at the given `line` and `column`, or `-1` if there is none.
+     * If `includeEdges` is `false`, the position must be inside the selection and not at either end. If `onlySelections` is `false`, carets without a selection will also be considered.
+     */
+    getSelectionAtLineColumn(line: number, column: number, includeEdges?: boolean /* = true */, onlySelections?: boolean /* = true */): number { return _C(this, 6330, line, column, includeEdges, onlySelections) as number; }
+
+    /**
+     * Returns an {@link Array} of line ranges where `x` is the first line and `y` is the last line. All lines within these ranges will have a caret on them or be part of a selection. Each line will only be part of one line range, even if it has multiple carets on it.
+     * If a selection's end column ({@link getSelectionToColumn}) is at column `0`, that line will not be included. If a selection begins on the line after another selection ends and `mergeAdjacent` is `true`, or they begin and end on the same line, one line range will include both selections.
+     */
+    getLineRangesFromCarets(onlySelections?: boolean /* = false */, mergeAdjacent?: boolean /* = true */): GodotArray<Vector2i> { return _C(this, 5369, onlySelections, mergeAdjacent) as GodotArray<Vector2i>; }
+
+    /**
+     * Returns the origin line of the selection. This is the opposite end from the caret.
+     */
+    getSelectionOriginLine(caretIndex?: number /* = 0 */): number { return _C(this, 6339, caretIndex) as number; }
+
+    /**
+     * Returns the origin column of the selection. This is the opposite end from the caret.
+     */
+    getSelectionOriginColumn(caretIndex?: number /* = 0 */): number { return _C(this, 6338, caretIndex) as number; }
+
+    /**
+     * Sets the selection origin line to the `line` for the given `caretIndex`. If the selection origin is moved to the caret position, the selection will deselect.
+     * If `canBeHidden` is `false`, The line will be set to the nearest unhidden line below or above.
+     * If `wrapIndex` is `-1`, the selection origin column will be clamped to the `line`'s length. If `wrapIndex` is greater than `-1`, the column will be moved to attempt to match the visual x position on the line's `wrapIndex` to the position from the last time {@link setSelectionOriginColumn} or {@link select} was called.
+     */
+    setSelectionOriginLine(line: number, canBeHidden?: boolean /* = true */, wrapIndex?: number /* = -1 */, caretIndex?: number /* = 0 */): void { _C(this, 12693, line, canBeHidden, wrapIndex, caretIndex); }
+
+    /**
+     * Sets the selection origin column to the `column` for the given `caretIndex`. If the selection origin is moved to the caret position, the selection will deselect.
+     */
+    setSelectionOriginColumn(column: number, caretIndex?: number /* = 0 */): void { _C(this, 12692, column, caretIndex); }
+
+    /**
+     * Returns the selection begin line. Returns the caret line if there is no selection.
+     */
+    getSelectionFromLine(caretIndex?: number /* = 0 */): number { return _C(this, 6334, caretIndex) as number; }
+
+    /**
+     * Returns the selection begin column. Returns the caret column if there is no selection.
+     */
+    getSelectionFromColumn(caretIndex?: number /* = 0 */): number { return _C(this, 6333, caretIndex) as number; }
+
+    /**
+     * Returns the selection end line. Returns the caret line if there is no selection.
+     */
+    getSelectionToLine(caretIndex?: number /* = 0 */): number { return _C(this, 6342, caretIndex) as number; }
+
+    /**
+     * Returns the selection end column. Returns the caret column if there is no selection.
+     */
+    getSelectionToColumn(caretIndex?: number /* = 0 */): number { return _C(this, 6341, caretIndex) as number; }
+
+    /**
+     * Returns `true` if the caret of the selection is after the selection origin. This can be used to determine the direction of the selection.
+     */
+    isCaretAfterSelectionOrigin(caretIndex?: number /* = 0 */): boolean { return _C(this, 7818, caretIndex) as boolean; }
+
+    /**
+     * Deselects the current selection.
+     */
+    deselect(caretIndex?: number /* = -1 */): void { _C(this, 2755, caretIndex); }
+
+    /**
+     * Deletes the selected text.
+     */
+    deleteSelection(caretIndex?: number /* = -1 */): void { _C(this, 2726, caretIndex); }
+
+    /**
+     * Returns if the given line is wrapped.
+     */
+    isLineWrapped(line: number): boolean { return _C(this, 8084, line) as boolean; }
+
+    /**
+     * Returns the number of times the given line is wrapped.
+     */
+    getLineWrapCount(line: number): number { return _C(this, 5378, line) as number; }
+
+    /**
+     * Returns the wrap index of the given column on the given line. This ranges from `0` to {@link getLineWrapCount}.
+     */
+    getLineWrapIndexAtColumn(line: number, column: number): number { return _C(this, 5379, line, column) as number; }
+
+    /**
+     * Returns an array of {@link String}s representing each wrapped index.
+     */
+    getLineWrappedText(line: number): PackedStringArray { return _C(this, 5380, line) as PackedStringArray; }
+
+    /**
+     * Returns the {@link VScrollBar} of the {@link TextEdit}.
+     */
+    getVScrollBar(): VScrollBar { return _C(this, 7014) as VScrollBar; }
+
+    /**
+     * Returns the {@link HScrollBar} used by {@link TextEdit}.
+     */
+    getHScrollBar(): HScrollBar { return _C(this, 5003) as HScrollBar; }
+
+    /**
+     * Returns the scroll position for `wrapIndex` of `line`.
+     */
+    getScrollPosForLine(line: number, wrapIndex?: number /* = 0 */): number { return _C(this, 6282, line, wrapIndex) as number; }
+
+    /**
+     * Positions the `wrapIndex` of `line` at the top of the viewport.
+     */
+    setLineAsFirstVisible(line: number, wrapIndex?: number /* = 0 */): void { _C(this, 11916, line, wrapIndex); }
+
+    /**
+     * Returns the first visible line.
+     */
+    getFirstVisibleLine(): number { return _C(this, 4795) as number; }
+
+    /**
+     * Returns `true` if the given line is within the scope of the scrollable area of the viewport.
+     */
+    isLineInViewport(line: number): boolean { return _C(this, 8082, line) as boolean; }
+
+    /**
+     * Positions the `wrapIndex` of `line` at the center of the viewport.
+     */
+    setLineAsCenterVisible(line: number, wrapIndex?: number /* = 0 */): void { _C(this, 11914, line, wrapIndex); }
+
+    /**
+     * Positions the `wrapIndex` of `line` at the bottom of the viewport.
+     */
+    setLineAsLastVisible(line: number, wrapIndex?: number /* = 0 */): void { _C(this, 11917, line, wrapIndex); }
+
+    /**
+     * Returns the last visible line. Use {@link getLastFullVisibleLineWrapIndex} for the wrap index.
+     */
+    getLastFullVisibleLine(): number { return _C(this, 5304) as number; }
+
+    /**
+     * Returns the last visible wrap index of the last visible line.
+     */
+    getLastFullVisibleLineWrapIndex(): number { return _C(this, 5305) as number; }
+
+    /**
+     * Returns the number of lines that can visually fit, rounded down, based on this control's height.
+     */
+    getVisibleLineCount(): number { return _C(this, 7108) as number; }
+
+    /**
+     * Returns the total number of lines between `fromLine` and `toLine` (inclusive) in the text. This includes wrapped lines and excludes folded lines. If the range covers all lines it is equivalent to {@link getTotalVisibleLineCount}.
+     */
+    getVisibleLineCountInRange(fromLine: number, toLine: number): number { return _C(this, 7109, fromLine, toLine) as number; }
+
+    /**
+     * Returns the total number of lines in the text. This includes wrapped lines and excludes folded lines. If {@link wrapMode} is set to {@link LINE_WRAPPING_NONE} and no lines are folded (see {@link CodeEdit.isLineFolded}) then this is equivalent to {@link getLineCount}. See {@link getVisibleLineCountInRange} for a limited range of lines.
+     */
+    getTotalVisibleLineCount(): number { return _C(this, 6856) as number; }
+
+    /**
+     * Adjust the viewport so the caret is visible.
+     */
+    adjustViewportToCaret(caretIndex?: number /* = 0 */): void { _C(this, 1340, caretIndex); }
+
+    /**
+     * Centers the viewport on the line the editing caret is at. This also resets the {@link scrollHorizontal} value to `0`.
+     */
+    centerViewportToCaret(caretIndex?: number /* = 0 */): void { _C(this, 2180, caretIndex); }
+
+    /**
+     * Returns the number of lines that may be drawn on the minimap.
+     */
+    getMinimapVisibleLines(): number { return _C(this, 5551) as number; }
+
+    /**
+     * Register a new gutter to this {@link TextEdit}. Use `at` to have a specific gutter order. A value of `-1` appends the gutter to the right.
+     */
+    addGutter(at?: number /* = -1 */): void { _C(this, 1225, at); }
+
+    /**
+     * Removes the gutter at the given index.
+     */
+    removeGutter(gutter: number): void { _C(this, 9917, gutter); }
+
+    /**
+     * Returns the number of gutters registered.
+     */
+    getGutterCount(): number { return _C(this, 4994) as number; }
+
+    /**
+     * Sets the name of the gutter at the given index.
+     */
+    setGutterName(gutter: number, name: string): void { _C(this, 11579, gutter, name); }
+
+    /**
+     * Returns the name of the gutter at the given index.
+     */
+    getGutterName(gutter: number): string { return _C(this, 4995, gutter) as string; }
+
+    /**
+     * Sets the type of gutter at the given index. Gutters can contain icons, text, or custom visuals.
+     */
+    setGutterType(gutter: number, type: GutterType): void { _C(this, 11581, gutter, type); }
+
+    /**
+     * Returns the type of the gutter at the given index. Gutters can contain icons, text, or custom visuals.
+     */
+    getGutterType(gutter: number): GutterType { return _C(this, 4996, gutter) as GutterType; }
+
+    /**
+     * Set the width of the gutter at the given index.
+     */
+    setGutterWidth(gutter: number, width: number): void { _C(this, 11582, gutter, width); }
+
+    /**
+     * Returns the width of the gutter at the given index.
+     */
+    getGutterWidth(gutter: number): number { return _C(this, 4997, gutter) as number; }
+
+    /**
+     * If `true`, the gutter at the given index is drawn. The gutter type ({@link setGutterType}) determines how it is drawn. See {@link isGutterDrawn}.
+     */
+    setGutterDraw(gutter: number, draw: boolean): void { _C(this, 11578, gutter, draw); }
+
+    /**
+     * Returns `true` if the gutter at the given index is currently drawn. See {@link setGutterDraw}.
+     */
+    isGutterDrawn(gutter: number): boolean { return _C(this, 7982, gutter) as boolean; }
+
+    /**
+     * If `true`, the mouse cursor will change to a pointing hand ({@link Control.CURSOR_POINTING_HAND}) when hovering over the gutter at the given index. See {@link isGutterClickable} and {@link setLineGutterClickable}.
+     */
+    setGutterClickable(gutter: number, clickable: boolean): void { _C(this, 11576, gutter, clickable); }
+
+    /**
+     * Returns `true` if the gutter at the given index is clickable. See {@link setGutterClickable}.
+     */
+    isGutterClickable(gutter: number): boolean { return _C(this, 7981, gutter) as boolean; }
+
+    /**
+     * If `true`, the line data of the gutter at the given index can be overridden when using {@link mergeGutters}. See {@link isGutterOverwritable}.
+     */
+    setGutterOverwritable(gutter: number, overwritable: boolean): void { _C(this, 11580, gutter, overwritable); }
+
+    /**
+     * Returns `true` if the gutter at the given index is overwritable. See {@link setGutterOverwritable}.
+     */
+    isGutterOverwritable(gutter: number): boolean { return _C(this, 7983, gutter) as boolean; }
+
+    /**
+     * Merge the gutters from `fromLine` into `toLine`. Only overwritable gutters will be copied. See {@link setGutterOverwritable}.
+     */
+    mergeGutters(fromLine: number, toLine: number): void { _C(this, 8851, fromLine, toLine); }
+
+    /**
+     * Set a custom draw callback for the gutter at the given index. `drawCallback` must take the following arguments: A line index {@link int}, a gutter index {@link int}, and an area {@link Rect2}. This callback only works when the gutter type is {@link GUTTER_TYPE_CUSTOM} (see {@link setGutterType}).
+     */
+    setGutterCustomDraw(column: number, drawCallback: Callable): void { _C(this, 11577, column, drawCallback); }
+
+    /**
+     * Returns the total width of all gutters and internal padding.
+     */
+    getTotalGutterWidth(): number { return _C(this, 6853) as number; }
+
+    /**
+     * Sets the metadata for `gutter` on `line` to `metadata`.
+     */
+    setLineGutterMetadata(line: number, gutter: number, metadata: Variant): void { _C(this, 11923, line, gutter, metadata); }
+
+    /**
+     * Returns the metadata currently in `gutter` at `line`.
+     */
+    getLineGutterMetadata(line: number, gutter: number): Variant { return _C(this, 5360, line, gutter) as Variant; }
+
+    /**
+     * Sets the text for `gutter` on `line` to `text`. This only works when the gutter type is {@link GUTTER_TYPE_STRING} (see {@link setGutterType}).
+     */
+    setLineGutterText(line: number, gutter: number, text: string): void { _C(this, 11924, line, gutter, text); }
+
+    /**
+     * Returns the text currently in `gutter` at `line`. This only works when the gutter type is {@link GUTTER_TYPE_STRING} (see {@link setGutterType}).
+     */
+    getLineGutterText(line: number, gutter: number): string { return _C(this, 5361, line, gutter) as string; }
+
+    /**
+     * Sets the icon for `gutter` on `line` to `icon`. This only works when the gutter type is {@link GUTTER_TYPE_ICON} (see {@link setGutterType}).
+     */
+    setLineGutterIcon(line: number, gutter: number, icon: Texture2D): void { _C(this, 11921, line, gutter, icon); }
+
+    /**
+     * Returns the icon currently in `gutter` at `line`. This only works when the gutter type is {@link GUTTER_TYPE_ICON} (see {@link setGutterType}).
+     */
+    getLineGutterIcon(line: number, gutter: number): Texture2D { return _C(this, 5358, line, gutter) as Texture2D; }
+
+    /**
+     * Sets the color for `gutter` on `line` to `color`.
+     */
+    setLineGutterItemColor(line: number, gutter: number, color: Color): void { _C(this, 11922, line, gutter, color); }
+
+    /**
+     * Returns the color currently in `gutter` at `line`.
+     */
+    getLineGutterItemColor(line: number, gutter: number): Color { return _C(this, 5359, line, gutter) as Color; }
+
+    /**
+     * If `clickable` is `true`, makes the `gutter` on the given `line` clickable. This is like {@link setGutterClickable}, but for a single line. If {@link isGutterClickable} is `true`, this will not have any effect. See {@link isLineGutterClickable} and {@link gutter_clicked}.
+     */
+    setLineGutterClickable(line: number, gutter: number, clickable: boolean): void { _C(this, 11920, line, gutter, clickable); }
+
+    /**
+     * Returns `true` if the gutter at the given index on the given line is clickable. See {@link setLineGutterClickable}.
+     */
+    isLineGutterClickable(line: number, gutter: number): boolean { return _C(this, 8081, line, gutter) as boolean; }
+
+    /**
+     * Sets the custom background color of the given line. If transparent, this color is applied on top of the default background color (See {@link background_color}). If set to `Color(0, 0, 0, 0)`, no additional color is applied.
+     */
+    setLineBackgroundColor(line: number, color: Color): void { _C(this, 11918, line, color); }
+
+    /**
+     * Returns the custom background color of the given line. If no color is set, returns `Color(0, 0, 0, 0)`.
+     */
+    getLineBackgroundColor(line: number): Color { return _C(this, 5353, line) as Color; }
+
+    /**
+     * Returns the {@link PopupMenu} of this {@link TextEdit}. By default, this menu is displayed when right-clicking on the {@link TextEdit}.
+     * You can add custom menu items or remove standard ones. Make sure your IDs don't conflict with the standard ones (see {@link MenuItems}). For example:
+     *
+     *
+     * ```gdscript
+     *
+     * func _ready():
+     * 	var menu = get_menu()
+     * 	# Remove all items after "Redo".
+     * 	menu.item_count = menu.get_item_index(MENU_REDO) + 1
+     * 	# Add custom items.
+     * 	menu.add_separator()
+     * 	menu.add_item("Insert Date", MENU_MAX + 1)
+     * 	# Connect callback.
+     * 	menu.id_pressed.connect(_on_item_pressed)
+     *
+     * func _on_item_pressed(id):
+     * 	if id == MENU_MAX + 1:
+     * 		insert_text_at_caret(Time.get_date_string_from_system())
+     *
+     * ```
+     *
+     *
+     *
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link Window.visible} property.
+     */
+    getMenu(): PopupMenu { return _C(this, 5505) as PopupMenu; }
+
+    /**
+     * Returns `true` if the menu is visible. Use this instead of `get_menu().visible` to improve performance (so the creation of the menu is avoided). See {@link getMenu}.
+     */
+    isMenuVisible(): boolean { return _C(this, 8101) as boolean; }
+
+    /**
+     * Executes a given action as defined in the {@link MenuItems} enum.
+     */
+    menuOption(option: number): void { _C(this, 8849, option); }
+
+    /**
+     * This method does nothing.
+     */
+    adjustCaretsAfterEdit(caret: number, fromLine: number, fromCol: number, toLine: number, toCol: number): void { _C(this, 1339, caret, fromLine, fromCol, toLine, toCol); }
+
+    /**
+     * Returns a list of caret indexes in their edit order, this done from bottom to top. Edit order refers to the way actions such as {@link insertTextAtCaret} are applied.
+     */
+    getCaretIndexEditOrder(): PackedInt32Array { return _C(this, 4091) as PackedInt32Array; }
+
+    /**
+     * Returns the original start line of the selection.
+     */
+    getSelectionLine(caretIndex?: number /* = 0 */): number { return _C(this, 6335, caretIndex) as number; }
+
+    /**
+     * Returns the original start column of the selection.
+     */
+    getSelectionColumn(caretIndex?: number /* = 0 */): number { return _C(this, 6331, caretIndex) as number; }
+
+    /**
+     * String value of the {@link TextEdit}.
+     */
+    get text(): string { return _C(this, 6718) as string; }
+    set text(v: string) { _C(this, 13020, v); }
+
+    /**
+     * Text shown when the {@link TextEdit} is empty. It is **not** the {@link TextEdit}'s default value (see {@link text}).
+     */
+    get placeholderText(): string { return _C(this, 5917) as string; }
+    set placeholderText(v: string) { _C(this, 12336, v); }
+
+    /**
+     * If `false`, existing text cannot be modified and new text cannot be added.
+     */
+    get editable(): boolean { return _C(this, 7916) as boolean; }
+    set editable(v: boolean) { _C(this, 11216, v); }
+
+    /**
+     * If `true`, a right-click displays the context menu.
+     */
+    get contextMenuEnabled(): boolean { return _C(this, 7860) as boolean; }
+    set contextMenuEnabled(v: boolean) { _C(this, 10959, v); }
+
+    /**
+     * If `true`, "Emoji and Symbols" menu is enabled.
+     */
+    get emojiMenuEnabled(): boolean { return _C(this, 7930) as boolean; }
+    set emojiMenuEnabled(v: boolean) { _C(this, 11257, v); }
+
+    /**
+     * If `true` and {@link caretMidGrapheme} is `false`, backspace deletes an entire composite character such as ❤️‍🩹, instead of deleting part of the composite character.
+     */
+    get backspaceDeletesCompositeCharacterEnabled(): boolean { return _C(this, 7788) as boolean; }
+    set backspaceDeletesCompositeCharacterEnabled(v: boolean) { _C(this, 10626, v); }
+
+    /**
+     * If `true`, shortcut keys for context menu items are enabled, even if the context menu is disabled.
+     */
+    get shortcutKeysEnabled(): boolean { return _C(this, 8305) as boolean; }
+    set shortcutKeysEnabled(v: boolean) { _C(this, 12728, v); }
+
+    /**
+     * If `true`, text can be selected.
+     * If `false`, text can not be selected by the user or by the {@link select} or {@link selectAll} methods.
+     */
+    get selectingEnabled(): boolean { return _C(this, 8288) as boolean; }
+    set selectingEnabled(v: boolean) { _C(this, 12689, v); }
+
+    /**
+     * If `true`, the selected text will be deselected when focus is lost.
+     */
+    get deselectOnFocusLossEnabled(): boolean { return _C(this, 7879) as boolean; }
+    set deselectOnFocusLossEnabled(v: boolean) { _C(this, 11099, v); }
+
+    /**
+     * If `true`, allow drag and drop of selected text. Text can still be dropped from other sources.
+     */
+    get dragAndDropSelectionEnabled(): boolean { return _C(this, 7893) as boolean; }
+    set dragAndDropSelectionEnabled(v: boolean) { _C(this, 11161, v); }
+
+    /**
+     * If `false`, using middle mouse button to paste clipboard will be disabled.
+     * **Note:** This method is only implemented on Linux.
+     */
+    get middleMousePasteEnabled(): boolean { return _C(this, 8106) as boolean; }
+    set middleMousePasteEnabled(v: boolean) { _C(this, 12044, v); }
+
+    /**
+     * If `true`, copying or cutting without a selection is performed on all lines with a caret. Otherwise, copy and cut require a selection.
+     */
+    get emptySelectionClipboardEnabled(): boolean { return _C(this, 7932) as boolean; }
+    set emptySelectionClipboardEnabled(v: boolean) { _C(this, 11258, v); }
+
+    /**
+     * Sets the line wrapping mode to use.
+     */
+    get wrapMode(): LineWrappingMode { return _C(this, 5381) as LineWrappingMode; }
+    set wrapMode(v: LineWrappingMode) { _C(this, 11930, v); }
+
+    /**
+     * If {@link wrapMode} is set to {@link LINE_WRAPPING_BOUNDARY}, sets text wrapping mode.
+     */
+    get autowrapMode(): AutowrapMode { return _C(this, 3847) as AutowrapMode; }
+    set autowrapMode(v: AutowrapMode) { _C(this, 10596, v); }
+
+    /**
+     * If `true`, all wrapped lines are indented to the same amount as the unwrapped line.
+     */
+    get indentWrappedLines(): boolean { return _C(this, 8021) as boolean; }
+    set indentWrappedLines(v: boolean) { _C(this, 11685, v); }
+
+    /**
+     * If `true`, {@link ProjectSettings.input/uiTextIndent} input `Tab` character, otherwise it moves keyboard focus to the next {@link Control} in the scene.
+     */
+    get tabInputMode(): boolean { return _C(this, 6677) as boolean; }
+    set tabInputMode(v: boolean) { _C(this, 12977, v); }
+
+    /**
+     * If `true`, the native virtual keyboard is enabled on platforms that support it.
+     */
+    get virtualKeyboardEnabled(): boolean { return _C(this, 8448) as boolean; }
+    set virtualKeyboardEnabled(v: boolean) { _C(this, 13313, v); }
+
+    /**
+     * If `true`, the native virtual keyboard is shown on focus events on platforms that support it.
+     */
+    get virtualKeyboardShowOnFocus(): boolean { return _C(this, 7087) as boolean; }
+    set virtualKeyboardShowOnFocus(v: boolean) { _C(this, 13314, v); }
+
+    /**
+     * Scroll smoothly over the text rather than jumping to the next location.
+     */
+    get scrollSmooth(): boolean { return _C(this, 8324) as boolean; }
+    set scrollSmooth(v: boolean) { _C(this, 12797, v); }
+
+    /**
+     * Sets the scroll speed with the minimap or when {@link scrollSmooth} is enabled.
+     */
+    get scrollVScrollSpeed(): number { return _C(this, 7015) as number; }
+    set scrollVScrollSpeed(v: number) { _C(this, 13266, v); }
+
+    /**
+     * Allow scrolling past the last line into "virtual" space.
+     */
+    get scrollPastEndOfFile(): boolean { return _C(this, 8277) as boolean; }
+    set scrollPastEndOfFile(v: boolean) { _C(this, 12641, v); }
+
+    /**
+     * If there is a vertical scrollbar, this determines the current vertical scroll value in line numbers, starting at 0 for the top line.
+     */
+    get scrollVertical(): number { return _C(this, 7013) as number; }
+    set scrollVertical(v: number) { _C(this, 13264, v); }
+
+    /**
+     * If there is a horizontal scrollbar, this determines the current horizontal scroll value in pixels.
+     */
+    get scrollHorizontal(): number { return _C(this, 5002) as number; }
+    set scrollHorizontal(v: number) { _C(this, 11587, v); }
+
+    /**
+     * If `true`, {@link TextEdit} fits its minimum height to the number of visible lines instead of scrolling vertically. If a maximum height is set (for example via {@link Control.customMaximumSize}) and content exceeds it, a vertical scrollbar is shown.
+     */
+    get scrollFitContentHeight(): boolean { return _C(this, 7953) as boolean; }
+    set scrollFitContentHeight(v: boolean) { _C(this, 11398, v); }
+
+    /**
+     * If `true`, {@link TextEdit} fits its minimum width to the widest line instead of scrolling horizontally. If a maximum width is set (for example via {@link Control.customMaximumSize}) and content exceeds it, a horizontal scrollbar is shown.
+     */
+    get scrollFitContentWidth(): boolean { return _C(this, 7954) as boolean; }
+    set scrollFitContentWidth(v: boolean) { _C(this, 11399, v); }
+
+    /**
+     * If `true`, a minimap is shown, providing an outline of your source code. The minimap uses a fixed-width text size.
+     */
+    get minimapDraw(): boolean { return _C(this, 7911) as boolean; }
+    set minimapDraw(v: boolean) { _C(this, 11192, v); }
+
+    /**
+     * The width, in pixels, of the minimap.
+     */
+    get minimapWidth(): number { return _C(this, 5552) as number; }
+    set minimapWidth(v: number) { _C(this, 12061, v); }
+
+    /**
+     * Set the type of caret to draw.
+     */
+    get caretType(): CaretType { return _C(this, 4093) as CaretType; }
+    set caretType(v: CaretType) { _C(this, 10808, v); }
+
+    /**
+     * If `true`, makes the caret blink.
+     */
+    get caretBlink(): boolean { return _C(this, 7819) as boolean; }
+    set caretBlink(v: boolean) { _C(this, 10802, v); }
+
+    /**
+     * The interval at which the caret blinks (in seconds).
+     */
+    get caretBlinkInterval(): number { return _C(this, 4087) as number; }
+    set caretBlinkInterval(v: number) { _C(this, 10803, v); }
+
+    /**
+     * If `true`, caret will be visible when {@link editable} is disabled.
+     */
+    get caretDrawWhenEditableDisabled(): boolean { return _C(this, 7908) as boolean; }
+    set caretDrawWhenEditableDisabled(v: boolean) { _C(this, 11184, v); }
+
+    /**
+     * If `true`, a right-click moves the caret at the mouse position before displaying the context menu.
+     * If `false`, the context menu ignores mouse location.
+     */
+    get caretMoveOnRightClick(): boolean { return _C(this, 8119) as boolean; }
+    set caretMoveOnRightClick(v: boolean) { _C(this, 12098, v); }
+
+    /**
+     * Allow moving caret, selecting and removing the individual composite character components.
+     * **Note:** `Backspace` is always removing individual composite character components.
+     */
+    get caretMidGrapheme(): boolean { return _C(this, 7821) as boolean; }
+    set caretMidGrapheme(v: boolean) { _C(this, 10807, v); }
+
+    /**
+     * If `true`, multiple carets are allowed. Left-clicking with `Alt` adds a new caret. See {@link addCaret} and {@link getCaretCount}.
+     */
+    get caretMultiple(): boolean { return _C(this, 8124) as boolean; }
+    set caretMultiple(v: boolean) { _C(this, 12111, v); }
+
+    /**
+     * If `false`, using `Ctrl + Left` or `Ctrl + Right` (`Cmd + Left` or `Cmd + Right` on macOS) bindings will stop moving caret only if a space or punctuation is detected. If `true`, it will also stop the caret if a character is part of `!"#$%&'()*+,-./:;<=>?@[\]^`{|}~`, the Unicode General Punctuation table, or the Unicode CJK Punctuation table. Useful for subword moving. This behavior also will be applied to the behavior of text selection.
+     */
+    get useDefaultWordSeparators(): boolean { return _C(this, 7875) as boolean; }
+    set useDefaultWordSeparators(v: boolean) { _C(this, 13209, v); }
+
+    /**
+     * If `false`, using `Ctrl + Left` or `Ctrl + Right` (`Cmd + Left` or `Cmd + Right` on macOS) bindings will use the behavior of {@link useDefaultWordSeparators}. If `true`, it will also stop the caret if a character within {@link customWordSeparators} is detected. Useful for subword moving. This behavior also will be applied to the behavior of text selection.
+     */
+    get useCustomWordSeparators(): boolean { return _C(this, 7866) as boolean; }
+    set useCustomWordSeparators(v: boolean) { _C(this, 13207, v); }
+
+    /**
+     * The characters to consider as word delimiters if {@link useCustomWordSeparators} is `true`. The characters should be defined without separation, for example `#_!`.
+     */
+    get customWordSeparators(): string { return _C(this, 4402) as string; }
+    set customWordSeparators(v: string) { _C(this, 11025, v); }
+
+    /**
+     * The syntax highlighter to use.
+     * **Note:** A {@link SyntaxHighlighter} instance should not be used across multiple {@link TextEdit} nodes.
+     */
+    get syntaxHighlighter(): SyntaxHighlighter { return _C(this, 6655) as SyntaxHighlighter; }
+    set syntaxHighlighter(v: SyntaxHighlighter) { _C(this, 12964, v); }
+
+    /**
+     * If `true`, all occurrences of the selected text will be highlighted.
+     */
+    get highlightAllOccurrences(): boolean { return _C(this, 7995) as boolean; }
+    set highlightAllOccurrences(v: boolean) { _C(this, 11629, v); }
+
+    /**
+     * If `true`, the line containing the cursor is highlighted.
+     */
+    get highlightCurrentLine(): boolean { return _C(this, 7996) as boolean; }
+    set highlightCurrentLine(v: boolean) { _C(this, 11630, v); }
+
+    /**
+     * If `true`, control characters are displayed.
+     */
+    get drawControlChars(): boolean { return _C(this, 4564) as boolean; }
+    set drawControlChars(v: boolean) { _C(this, 11186, v); }
+
+    /**
+     * If `true`, the "tab" character will have a visible representation.
+     */
+    get drawTabs(): boolean { return _C(this, 7913) as boolean; }
+    set drawTabs(v: boolean) { _C(this, 11197, v); }
+
+    /**
+     * If `true`, the "space" character will have a visible representation.
+     */
+    get drawSpaces(): boolean { return _C(this, 7912) as boolean; }
+    set drawSpaces(v: boolean) { _C(this, 11196, v); }
+
+    /**
+     * Base text writing direction.
+     */
+    get textDirection(): TextDirection { return _C(this, 6720) as TextDirection; }
+    set textDirection(v: TextDirection) { _C(this, 13022, v); }
+
+    /**
+     * Language code used for line-breaking and text shaping algorithms. If left empty, the current locale is used instead.
+     */
+    get language(): string { return _C(this, 5299) as string; }
+    set language(v: string) { _C(this, 11871, v); }
+
+    /**
+     * Set BiDi algorithm override for the structured text.
+     */
+    get structuredTextBidiOverride(): StructuredTextParser { return _C(this, 6585) as StructuredTextParser; }
+    set structuredTextBidiOverride(v: StructuredTextParser) { _C(this, 12913, v); }
+
+    /**
+     * Set additional options for BiDi override.
+     */
+    get structuredTextBidiOverrideOptions(): GodotArray { return _C(this, 6586) as GodotArray; }
+    set structuredTextBidiOverrideOptions(v: GodotArray) { _C(this, 12914, v); }
+
+    /**
+     * Emitted when {@link clear} is called or {@link text} is set.
+     */
+    get textSet(): Signal<() => void> { return _G(this, 14157) as Signal<() => void>; }
+    set textSet(v: (() => void) | null) { _G(this, 14157, v); }
+
+    /**
+     * Emitted when the text changes.
+     */
+    get textChanged(): Signal<() => void> { return _G(this, 14154) as Signal<() => void>; }
+    set textChanged(v: (() => void) | null) { _G(this, 14154, v); }
+
+    /**
+     * Emitted immediately when the text changes.
+     * When text is added `fromLine` will be less than `toLine`. On a remove `toLine` will be less than `fromLine`.
+     */
+    get linesEditedFrom(): Signal<(fromLine: number, toLine: number) => void> { return _G(this, 8636) as Signal<(fromLine: number, toLine: number) => void>; }
+    set linesEditedFrom(v: ((fromLine: number, toLine: number) => void) | null) { _G(this, 8636, v); }
+
+    /**
+     * Emitted when any caret changes position.
+     */
+    get caretChanged(): Signal<() => void> { return _G(this, 2143) as Signal<() => void>; }
+    set caretChanged(v: (() => void) | null) { _G(this, 2143, v); }
+
+    /**
+     * Emitted when a gutter is clicked.
+     */
+    get gutterClicked(): Signal<(line: number, gutter: number) => void> { return _G(this, 7329) as Signal<(line: number, gutter: number) => void>; }
+    set gutterClicked(v: ((line: number, gutter: number) => void) | null) { _G(this, 7329, v); }
+
+    /**
+     * Emitted when a gutter is added.
+     */
+    get gutterAdded(): Signal<() => void> { return _G(this, 7328) as Signal<() => void>; }
+    set gutterAdded(v: (() => void) | null) { _G(this, 7328, v); }
+
+    /**
+     * Emitted when a gutter is removed.
+     */
+    get gutterRemoved(): Signal<() => void> { return _G(this, 7330) as Signal<() => void>; }
+    set gutterRemoved(v: (() => void) | null) { _G(this, 7330, v); }
+
+    static readonly name = _R(767, TextEdit);
+}
+
+export const MenuItems = {
+    /**
+     * Cuts (copies and clears) the selected text.
+     */
+    MENU_CUT: 0,
+    /**
+     * Copies the selected text.
+     */
+    MENU_COPY: 1,
+    /**
+     * Pastes the clipboard text over the selected text (or at the cursor's position).
+     */
+    MENU_PASTE: 2,
+    /**
+     * Erases the whole {@link TextEdit} text.
+     */
+    MENU_CLEAR: 3,
+    /**
+     * Selects the whole {@link TextEdit} text.
+     */
+    MENU_SELECT_ALL: 4,
+    /**
+     * Undoes the previous action.
+     */
+    MENU_UNDO: 5,
+    /**
+     * Redoes the previous action.
+     */
+    MENU_REDO: 6,
+    /**
+     * ID of "Text Writing Direction" submenu.
+     */
+    MENU_SUBMENU_TEXT_DIR: 7,
+    /**
+     * Sets text direction to inherited.
+     */
+    MENU_DIR_INHERITED: 8,
+    /**
+     * Sets text direction to automatic.
+     */
+    MENU_DIR_AUTO: 9,
+    /**
+     * Sets text direction to left-to-right.
+     */
+    MENU_DIR_LTR: 10,
+    /**
+     * Sets text direction to right-to-left.
+     */
+    MENU_DIR_RTL: 11,
+    /**
+     * Toggles control character display.
+     */
+    MENU_DISPLAY_UCC: 12,
+    /**
+     * ID of "Insert Control Character" submenu.
+     */
+    MENU_SUBMENU_INSERT_UCC: 13,
+    /**
+     * Inserts left-to-right mark (LRM) character.
+     */
+    MENU_INSERT_LRM: 14,
+    /**
+     * Inserts right-to-left mark (RLM) character.
+     */
+    MENU_INSERT_RLM: 15,
+    /**
+     * Inserts start of left-to-right embedding (LRE) character.
+     */
+    MENU_INSERT_LRE: 16,
+    /**
+     * Inserts start of right-to-left embedding (RLE) character.
+     */
+    MENU_INSERT_RLE: 17,
+    /**
+     * Inserts start of left-to-right override (LRO) character.
+     */
+    MENU_INSERT_LRO: 18,
+    /**
+     * Inserts start of right-to-left override (RLO) character.
+     */
+    MENU_INSERT_RLO: 19,
+    /**
+     * Inserts pop direction formatting (PDF) character.
+     */
+    MENU_INSERT_PDF: 20,
+    /**
+     * Inserts Arabic letter mark (ALM) character.
+     */
+    MENU_INSERT_ALM: 21,
+    /**
+     * Inserts left-to-right isolate (LRI) character.
+     */
+    MENU_INSERT_LRI: 22,
+    /**
+     * Inserts right-to-left isolate (RLI) character.
+     */
+    MENU_INSERT_RLI: 23,
+    /**
+     * Inserts first strong isolate (FSI) character.
+     */
+    MENU_INSERT_FSI: 24,
+    /**
+     * Inserts pop direction isolate (PDI) character.
+     */
+    MENU_INSERT_PDI: 25,
+    /**
+     * Inserts zero width joiner (ZWJ) character.
+     */
+    MENU_INSERT_ZWJ: 26,
+    /**
+     * Inserts zero width non-joiner (ZWNJ) character.
+     */
+    MENU_INSERT_ZWNJ: 27,
+    /**
+     * Inserts word joiner (WJ) character.
+     */
+    MENU_INSERT_WJ: 28,
+    /**
+     * Inserts soft hyphen (SHY) character.
+     */
+    MENU_INSERT_SHY: 29,
+    /**
+     * Opens system emoji and symbol picker.
+     */
+    MENU_EMOJI_AND_SYMBOL: 30,
+    /**
+     * Represents the size of the {@link MenuItems} enum.
+     */
+    MENU_MAX: 31,
+} as const;
+
+export type MenuItems = (typeof MenuItems)[keyof typeof MenuItems];
+
+export const EditAction = {
+    /**
+     * No current action.
+     */
+    ACTION_NONE: 0,
+    /**
+     * A typing action.
+     */
+    ACTION_TYPING: 1,
+    /**
+     * A backwards delete action.
+     */
+    ACTION_BACKSPACE: 2,
+    /**
+     * A forward delete action.
+     */
+    ACTION_DELETE: 3,
+} as const;
+
+export type EditAction = (typeof EditAction)[keyof typeof EditAction];
+
+export const SearchFlags = {
+    /**
+     * Match case when searching.
+     */
+    SEARCH_MATCH_CASE: 1,
+    /**
+     * Match whole words when searching.
+     */
+    SEARCH_WHOLE_WORDS: 2,
+    /**
+     * Search from end to beginning.
+     */
+    SEARCH_BACKWARDS: 4,
+} as const;
+
+export type SearchFlags = (typeof SearchFlags)[keyof typeof SearchFlags];
+
+export const CaretType = {
+    /**
+     * Vertical line caret.
+     */
+    CARET_TYPE_LINE: 0,
+    /**
+     * Block caret.
+     */
+    CARET_TYPE_BLOCK: 1,
+} as const;
+
+export type CaretType = (typeof CaretType)[keyof typeof CaretType];
+
+export const SelectionMode = {
+    /**
+     * Not selecting.
+     */
+    SELECTION_MODE_NONE: 0,
+    /**
+     * Select as if `shift` is pressed.
+     */
+    SELECTION_MODE_SHIFT: 1,
+    /**
+     * Select single characters as if the user single clicked.
+     */
+    SELECTION_MODE_POINTER: 2,
+    /**
+     * Select whole words as if the user double clicked.
+     */
+    SELECTION_MODE_WORD: 3,
+    /**
+     * Select whole lines as if the user triple clicked.
+     */
+    SELECTION_MODE_LINE: 4,
+} as const;
+
+export type SelectionMode = (typeof SelectionMode)[keyof typeof SelectionMode];
+
+export const LineWrappingMode = {
+    /**
+     * Line wrapping is disabled.
+     */
+    LINE_WRAPPING_NONE: 0,
+    /**
+     * Line wrapping occurs at the control boundary, beyond what would normally be visible.
+     */
+    LINE_WRAPPING_BOUNDARY: 1,
+} as const;
+
+export type LineWrappingMode = (typeof LineWrappingMode)[keyof typeof LineWrappingMode];
+
+export const GutterType = {
+    /**
+     * When a gutter is set to string using {@link setGutterType}, it is used to contain text set via the {@link setLineGutterText} method.
+     */
+    GUTTER_TYPE_STRING: 0,
+    /**
+     * When a gutter is set to icon using {@link setGutterType}, it is used to contain an icon set via the {@link setLineGutterIcon} method.
+     */
+    GUTTER_TYPE_ICON: 1,
+    /**
+     * When a gutter is set to custom using {@link setGutterType}, it is used to contain custom visuals controlled by a callback method set via the {@link setGutterCustomDraw} method.
+     */
+    GUTTER_TYPE_CUSTOM: 2,
+} as const;
+
+export type GutterType = (typeof GutterType)[keyof typeof GutterType];
+