typescript-to-gdscript 0.1.1 → 0.1.2

package/typings/classes/TextServerExtension.d.ts

@@ -112,6 +112,20 @@ declare class TextServerExtension extends TextServer {
    * Returns oversampling factor override. If set to a positive value, overrides the oversampling factor of the viewport this font is used in. See {@link Viewport.oversampling}. This value doesn't override the [code skip-lint]oversampling[/code] parameter of [code skip-lint]draw_*[/code] methods. Used by dynamic fonts only.
    */
   _font_get_oversampling(font_rid: RID): float;
+  /**
+   * Returns the array in the predefined color palette at `index`. Palette contains all colors used to render font glyphs. Each palette has the same number of colors. Colors can be overridden using {@link _font_set_palette_custom_colors}.
+   */
+  _font_get_palette_colors(font_rid: RID, index: int): PackedColorArray;
+  /**
+   * Returns the number of predefined color palettes. Palette contains all colors used to render font glyphs. Each palette has the same number of colors.
+   */
+  _font_get_palette_count(font_rid: RID): int;
+  /** Returns array of custom colors to override predefined palette. */
+  _font_get_palette_custom_colors(font_rid: RID): PackedColorArray;
+  /**
+   * Returns the name of the predefined color palette at `index`. Palette contains all colors used to render font glyphs. Each palette has the same number of colors.
+   */
+  _font_get_palette_name(font_rid: RID, index: int): string;
   /** Returns scaling factor of the color bitmap font. */
   _font_get_scale(font_rid: RID, size: int): float;
   /** Returns `true` if support override is enabled for the `script`. */
@@ -154,6 +168,8 @@ declare class TextServerExtension extends TextServer {
   _font_get_underline_position(font_rid: RID, size: int): float;
   /** Returns thickness of the underline in pixels. */
   _font_get_underline_thickness(font_rid: RID, size: int): float;
+  /** Returns used palette index. */
+  _font_get_used_palette(font_rid: RID): int;
   /** Returns variation coordinates for the specified font cache entry. */
   _font_get_variation_coordinates(font_rid: RID): Dictionary;
   /**
@@ -272,6 +288,10 @@ declare class TextServerExtension extends TextServer {
    * If set to a positive value, overrides the oversampling factor of the viewport this font is used in. See {@link Viewport.oversampling}. This value doesn't override the [code skip-lint]oversampling[/code] parameter of [code skip-lint]draw_*[/code] methods. Used by dynamic fonts only.
    */
   _font_set_oversampling(font_rid: RID, oversampling: float): void;
+  /**
+   * Sets array of custom colors to override predefined palette. Set to empty array to reset overrides. Use `Color(0, 0, 0, 0)`, to keep predefined palette color at specific position.
+   */
+  _font_set_palette_custom_colors(font_rid: RID, colors: PackedColorArray | Array<unknown>): void;
   /** Sets scaling factor of the color bitmap font. */
   _font_set_scale(font_rid: RID, size: int, scale: float): void;
   /** Adds override for {@link _font_is_script_supported}. */
@@ -298,6 +318,8 @@ declare class TextServerExtension extends TextServer {
   _font_set_underline_position(font_rid: RID, size: int, underline_position: float): void;
   /** Sets thickness of the underline in pixels. */
   _font_set_underline_thickness(font_rid: RID, size: int, underline_thickness: float): void;
+  /** Sets used palette index. */
+  _font_set_used_palette(font_rid: RID, index: int): void;
   /** Sets variation coordinates for the specified font cache entry. */
   _font_set_variation_coordinates(font_rid: RID, variation_coordinates: Dictionary): void;
   /**
@@ -371,6 +393,8 @@ declare class TextServerExtension extends TextServer {
   _shaped_get_run_font_rid(shaped: RID, index: int): RID;
   /** Returns the font size of the `index` text run (in visual order). */
   _shaped_get_run_font_size(shaped: RID, index: int): int;
+  /** Returns the glyph range of the `index` text run (in visual order). */
+  _shaped_get_run_glyph_range(shaped: RID, index: int): Vector2i;
   /** Returns the language of the `index` text run (in visual order). */
   _shaped_get_run_language(shaped: RID, index: int): string;
   /** Returns the embedded object of the `index` text run (in visual order). */
@@ -424,7 +448,7 @@ declare class TextServerExtension extends TextServer {
   /**
    * Returns shapes of the carets corresponding to the character offset `position` in the text. Returned caret shape is 1 pixel wide rectangle.
    */
-  _shaped_text_get_carets(shaped: RID, position: int, caret: unknown): void;
+  _shaped_text_get_carets(shaped: RID, position: int, r_caret: unknown): void;
   /** Returns array of the composite character boundaries. */
   _shaped_text_get_character_breaks(shaped: RID): PackedInt32Array;
   /** Returns ellipsis character used for text clipping. */

package/typings/classes/Texture2D.d.ts

@@ -18,12 +18,20 @@ declare class Texture2D extends Texture {
    * **Note:** This is only used in 2D rendering, not 3D.
    */
   _draw_rect_region(to_canvas_item: RID, rect: Rect2 | Rect2i, src_rect: Rect2 | Rect2i, modulate: Color, transpose: boolean, clip_uv: boolean): void;
+  /** Called when {@link get_format} is called. */
+  _get_format(): int;
   /** Called when the {@link Texture2D}'s height is queried. */
   _get_height(): int;
+  /** Called when {@link get_image} is called. */
+  _get_image(): Image | null;
+  /** Called when {@link get_mipmap_count} is called. */
+  _get_mipmap_count(): int;
   /** Called when the {@link Texture2D}'s width is queried. */
   _get_width(): int;
   /** Called when the presence of an alpha channel in the {@link Texture2D} is queried. */
   _has_alpha(): boolean;
+  /** Called when {@link has_mipmaps} is called. */
+  _has_mipmaps(): boolean;
   /**
    * Called when a pixel's opaque state in the {@link Texture2D} is queried at the specified `(x, y)` position.
    */
@@ -38,6 +46,8 @@ declare class Texture2D extends Texture {
   draw_rect(canvas_item: RID, rect: Rect2 | Rect2i, tile: boolean, modulate?: Color, transpose?: boolean): void;
   /** Draws a part of the texture using a {@link CanvasItem} with the {@link RenderingServer} API. */
   draw_rect_region(canvas_item: RID, rect: Rect2 | Rect2i, src_rect: Rect2 | Rect2i, modulate?: Color, transpose?: boolean, clip_uv?: boolean): void;
+  /** Returns the image format of the texture. */
+  get_format(): int;
   /** Returns the texture height in pixels. */
   get_height(): int;
   /**
@@ -46,10 +56,14 @@ declare class Texture2D extends Texture {
    * **Note:** This will fetch the texture data from the GPU, which might cause performance problems when overused. Avoid calling {@link get_image} every frame, especially on large textures.
    */
   get_image(): Image | null;
+  /** Returns the number of mipmaps of the texture. */
+  get_mipmap_count(): int;
   /** Returns the texture size in pixels. */
   get_size(): Vector2;
   /** Returns the texture width in pixels. */
   get_width(): int;
   /** Returns `true` if this {@link Texture2D} has an alpha channel. */
   has_alpha(): boolean;
+  /** Returns `true` if the texture has mipmaps. */
+  has_mipmaps(): boolean;
 }

package/typings/classes/TextureRect.d.ts

@@ -49,7 +49,10 @@ declare class TextureRect extends Control {
   // enum StretchMode
   /** Scale to fit the node's bounding rectangle. */
   static readonly STRETCH_SCALE: int;
-  /** Tile inside the node's bounding rectangle. */
+  /**
+   * Tile inside the node's bounding rectangle.
+   * **Note:** {@link STRETCH_TILE} mode is not supported for {@link texture} set to an {@link AtlasTexture} with non-zero {@link AtlasTexture.margin}.
+   */
   static readonly STRETCH_TILE: int;
   /** The texture keeps its original size and stays in the bounding rectangle's top-left corner. */
   static readonly STRETCH_KEEP: int;

package/typings/classes/TileSet.d.ts

@@ -70,6 +70,8 @@ declare class TileSet extends Resource {
   add_terrain_set(to_position?: int): void;
   /** Clears tile proxies pointing to invalid tiles. */
   cleanup_invalid_tile_proxies(): void;
+  /** Clears all terrain properties for the given terrain set. */
+  clear_terrains(terrain_set: int): void;
   /** Clears all tile proxies. */
   clear_tile_proxies(): void;
   /**
@@ -218,7 +220,7 @@ declare class TileSet extends Resource {
    * Creates a coordinates-level proxy for the given identifiers. A proxy will map set of tile identifiers to another set of identifiers. The alternative tile ID is kept the same when using coordinates-level proxies.
    * Proxied tiles can be automatically replaced in TileMapLayer nodes using the editor.
    */
-  set_coords_level_tile_proxy(p_source_from: int, coords_from: Vector2i | Vector2, source_to: int, coords_to: Vector2i | Vector2): void;
+  set_coords_level_tile_proxy(source_from: int, coords_from: Vector2i | Vector2, source_to: int, coords_to: Vector2i | Vector2): void;
   /**
    * Sets the name of the custom data layer identified by the given index. Names are identifiers of the layer therefore if the name is already taken it will fail and raise an error.
    */

package/typings/classes/Tree.d.ts

@@ -18,7 +18,10 @@ declare class Tree extends Control {
    * If `true`, column titles are visible.
    */
   clip_contents: boolean;
-  /** The number of columns. */
+  /**
+   * The number of columns.
+   * Prints an error and does not allow setting the columns during mouse selection.
+   */
   columns: int;
   /**
    * The drop mode as an OR combination of flags. See {@link DropModeFlags} constants. Once dropping is done, reverts to {@link DROP_MODE_DISABLED}. Setting this during {@link Control._can_drop_data} is recommended.
@@ -83,12 +86,16 @@ declare class Tree extends Control {
   set_tile_scroll_hint(value: boolean): void;
   is_scroll_hint_tiled(): boolean;
 
-  /** Clears the tree. This removes all items. */
+  /**
+   * Clears the tree. This removes all items.
+   * Prints an error and does not allow clearing the tree if called during mouse selection.
+   */
   clear(): void;
   /**
    * Creates an item in the tree and adds it as a child of `parent`, which can be either a valid {@link TreeItem} or `null`.
    * If `parent` is `null`, the root item will be the parent, or the new item will be the root itself if the tree is empty.
    * The new item will be the `index`-th child of parent, or it will be the last child if there are not enough siblings.
+   * Prints an error and returns `null` if called during mouse selection, or if the `parent` does not belong to this tree.
    */
   create_item(parent?: TreeItem, index?: int): TreeItem | null;
   /**
@@ -125,14 +132,23 @@ declare class Tree extends Control {
   get_column_title_tooltip_text(column: int): string;
   /** Returns the column's width in pixels. */
   get_column_width(column: int): int;
+  /**
+   * Returns the internal canvas item designated for custom drawing. See {@link TreeItem.set_custom_draw_callback}.
+   * **Note:** This canvas item clears automatically on each Tree draw call.
+   */
+  get_custom_drawing_canvas_item(): RID;
   /**
    * Returns the rectangle for custom popups. Helper to create custom cell controls that display a popup. See {@link TreeItem.set_cell_mode}.
    */
   get_custom_popup_rect(): Rect2;
   /**
-   * Returns the drop section at `position`, or -100 if no item is there.
-   * Values -1, 0, or 1 will be returned for the "above item", "on item", and "below item" drop sections, respectively. See {@link DropModeFlags} for a description of each drop section.
-   * To get the item which the returned drop section is relative to, use {@link get_item_at_position}.
+   * Returns the drop section at `position`, as permitted by enabled {@link DropModeFlags}.
+   * - `-1` if the position is **above** the item. Typically used to insert as the item's previous sibling.
+   * - `0` if the position is **on** the item. Typically used to insert as the item's last child.
+   * - `1` if the position is **below** the item, when the item has no children. Typically used to insert as the item's next sibling. If the item *does* have children, this section is still reachable by hovering to the left of the item's collapse arrow, and below.
+   * - `2` if the position is **below** the item, when the item has children. Typically used to insert as the item's first child.
+   * - `-100` if the position is not over any item, or no {@link DropModeFlags} are set.
+   * See {@link DropModeFlags} for a description of each drop region. To get the item which the returned drop section refers to, use {@link get_item_at_position}.
    */
   get_drop_section_at_position(position: Vector2 | Vector2i): int;
   /**
@@ -265,18 +281,18 @@ declare class Tree extends Control {
   static readonly SELECT_MULTI: int;
   // enum DropModeFlags
   /**
-   * Disables all drop sections, but still allows to detect the "on item" drop section by {@link get_drop_section_at_position}.
+   * Disables all drop sections.
    * **Note:** This is the default flag, it has no effect when combined with other flags.
    */
   static readonly DROP_MODE_DISABLED: int;
   /**
    * Enables the "on item" drop section. This drop section covers the entire item.
-   * When combined with {@link DROP_MODE_INBETWEEN}, this drop section halves the height and stays centered vertically.
+   * When combined with {@link DROP_MODE_INBETWEEN}, this drop section halves in height and stays centered vertically.
    */
   static readonly DROP_MODE_ON_ITEM: int;
   /**
-   * Enables "above item" and "below item" drop sections. The "above item" drop section covers the top half of the item, and the "below item" drop section covers the bottom half.
-   * When combined with {@link DROP_MODE_ON_ITEM}, these drop sections halves the height and stays on top / bottom accordingly.
+   * Enables "above item" and "below item" drop sections. The "above item" drop section covers the top half of the item, while the "below item" drop section covers the bottom half, and extends downward to the left of any children.
+   * When combined with {@link DROP_MODE_ON_ITEM}, these drop sections halve in height and stay at the top and bottom respectively.
    */
   static readonly DROP_MODE_INBETWEEN: int;
   // enum ScrollHintMode

package/typings/classes/TreeItem.d.ts

@@ -56,6 +56,10 @@ declare class TreeItem extends GodotObject {
    * Returns the text autowrap mode in the given `column`. By default it is {@link TextServer.AUTOWRAP_OFF}.
    */
   get_autowrap_mode(column: int): int;
+  /**
+   * Returns the autowrap trim flags for the given `column`. By default, both {@link TextServer.BREAK_TRIM_START_EDGE_SPACES} and {@link TextServer.BREAK_TRIM_END_EDGE_SPACES} are enabled.
+   */
+  get_autowrap_trim_flags(column: int): int;
   /** Returns the {@link Texture2D} of the button at index `button_index` in column `column`. */
   get_button(column: int, button_index: int): Texture2D | null;
   /**
@@ -171,6 +175,8 @@ declare class TreeItem extends GodotObject {
   get_tooltip_text(column: int): string;
   /** Returns the {@link Tree} that owns this TreeItem. */
   get_tree(): Tree | null;
+  /** Returns `true` if this {@link TreeItem} is allowed to accept children. */
+  is_accepting_children(): boolean;
   /**
    * Returns `true` if this {@link TreeItem}, or any of its descendants, is collapsed.
    * If `only_visible` is `true` it ignores non-visible {@link TreeItem}s.
@@ -213,8 +219,12 @@ declare class TreeItem extends GodotObject {
    * **Note:** If you want to move a child from one {@link Tree} to another, then instead of removing and adding it manually you can use {@link move_before} or {@link move_after}.
    */
   remove_child(child: TreeItem): void;
-  /** Selects the given `column`. */
-  select(column: int): void;
+  /**
+   * Selects the given `column`. If `set_as_cursor` is `true`, the {@link Tree}'s cursor will be moved to this item (only matters if {@link Tree.select_mode} is set to {@link Tree.SELECT_MULTI}).
+   */
+  select(column: int, set_as_cursor?: boolean): void;
+  /** Sets {@link TreeItem}'s ability to accept children. */
+  set_accept_children(allowed: boolean): void;
   /**
    * Sets the given column's auto translate mode to `mode`.
    * All columns use {@link Node.AUTO_TRANSLATE_MODE_INHERIT} by default, which uses the same auto translate mode as the {@link Tree} itself.
@@ -224,6 +234,10 @@ declare class TreeItem extends GodotObject {
    * Sets the autowrap mode in the given `column`. If set to something other than {@link TextServer.AUTOWRAP_OFF}, the text gets wrapped inside the cell's bounding rectangle.
    */
   set_autowrap_mode(column: int, autowrap_mode: int): void;
+  /**
+   * Sets the autowrap trim flags for the given `column`. These flags control whether leading and trailing spaces are trimmed on wrapped lines. Set to `0` to disable all trimming.
+   */
+  set_autowrap_trim_flags(column: int, flags: int): void;
   /** Sets the given column's button {@link Texture2D} at index `button_index` to `button`. */
   set_button(column: int, button_index: int, button: Texture2D): void;
   /** Sets the given column's button color at index `button_index` to `color`. */
@@ -257,6 +271,7 @@ declare class TreeItem extends GodotObject {
   /**
    * Sets the given column's custom draw callback. Use an empty {@link Callable} ([code skip-lint]Callable()[/code]) to clear the custom callback. The cell has to be in {@link CELL_MODE_CUSTOM} to use this feature.
    * The `callback` should accept two arguments: the {@link TreeItem} that is drawn and its position and size as a {@link Rect2}.
+   * To draw custom content over the native style, please use {@link Tree.get_custom_drawing_canvas_item}.
    */
   set_custom_draw_callback(column: int, callback: Callable): void;
   /** Sets custom font used to draw text in the given `column`. */

package/typings/classes/Tween.d.ts

@@ -24,6 +24,10 @@ declare class Tween extends RefCounted {
    * **Note:** As it results from accumulating frame deltas, the time returned after the {@link Tween} has finished animating will be slightly greater than the actual {@link Tween} duration.
    */
   get_total_elapsed_time(): float;
+  /**
+   * Returns `true` if any {@link Tweener} has been added to the {@link Tween} and the {@link Tween} is valid. Useful when tweeners are added dynamically and the tween can end up empty. Killing an empty tween before it starts will prevent errors.
+   */
+  has_tweeners(): boolean;
   /**
    * This method can be used for manual interpolation of a value, when you don't want {@link Tween} to do animating for you. It's similar to {@link @GlobalScope.lerp}, but with support for custom transition and easing.
    * `initial_value` is the starting value of the interpolation.
@@ -99,6 +103,15 @@ declare class Tween extends RefCounted {
    * **Note:** If a Tween is stopped and not bound to any node, it will exist indefinitely until manually started or invalidated. If you lose a reference to such Tween, you can retrieve it using {@link SceneTree.get_processed_tweens}.
    */
   stop(): void;
+  /**
+   * Creates and appends an {@link AwaitTweener}. This method can be used to await a signal to be emitted and create asynchronous animations or cutscenes.
+   * The animation will not progress to the next step until the awaited signal is emitted or the connection becomes invalid (e.g. as a result of freeing the target object). If you know that the emission may not happen, use {@link AwaitTweener.set_timeout}.
+   * **Note:** The awaited signal should be emitted during the step when {@link AwaitTweener} is active.
+   * **Example:** An object launches itself and explodes upon collision or after 4 seconds.
+   * **Example:** A character walks to a specific point, says some lines and walks back when the player closes the message box.
+   * **Note:** If you are awaiting a signal from a callback called in the same {@link Tween}, make sure the signal is emitted *after* the await starts. If it can't be reasonably guaranteed, you can await and emit in the same step:
+   */
+  tween_await(signal: Signal): AwaitTweener;
   /**
    * Creates and appends a {@link CallbackTweener}. This method can be used to call an arbitrary method in any object. Use {@link Callable.bind} to bind additional arguments for the call.
    * **Example:** Object that keeps shooting every 1 second:

package/typings/classes/UndoRedo.d.ts

@@ -68,13 +68,13 @@ declare class UndoRedo extends GodotObject {
    * Returns `true` if the {@link UndoRedo} is currently committing the action, i.e. running its "do" method or property change (see {@link commit_action}).
    */
   is_committing_action(): boolean;
-  /** Redo the last action. */
+  /** Redo the last action. Returns `false` if there was no action to redo. */
   redo(): boolean;
   /**
    * Marks the next "do" and "undo" operations to be processed even if the action gets merged with another in the {@link MERGE_ENDS} mode. Return to normal operation using {@link end_force_keep_in_merge_ends}.
    */
   start_force_keep_in_merge_ends(): void;
-  /** Undo the last action. */
+  /** Undo the last action. Returns `false` if there was no action to undo. */
   undo(): boolean;
 
   /** Called when {@link undo} or {@link redo} was called. */

package/typings/classes/Vector2.d.ts

@@ -74,11 +74,13 @@ declare interface Vector2 {
    */
   direction_to(to: Vector2 | Vector2i): Vector2;
   /**
-   * Returns the squared distance between this vector and `to`.
+   * Returns the squared Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
    * This method runs faster than {@link distance_to}, so prefer it if you need to compare vectors or need the squared distance for some formula.
    */
   distance_squared_to(to: Vector2 | Vector2i): float;
-  /** Returns the distance between this vector and `to`. */
+  /**
+   * Returns the Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+   */
   distance_to(to: Vector2 | Vector2i): float;
   /**
    * Returns the dot product of this vector and `with`. This can be used to compare the angle between two vectors. For example, this can be used to determine whether an enemy is facing the player.

package/typings/classes/Vector2i.d.ts

@@ -21,11 +21,13 @@ declare interface Vector2i {
    */
   clampi(min: int, max: int): Vector2i;
   /**
-   * Returns the squared distance between this vector and `to`.
+   * Returns the squared Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
    * This method runs faster than {@link distance_to}, so prefer it if you need to compare vectors or need the squared distance for some formula.
    */
   distance_squared_to(to: Vector2i | Vector2): int;
-  /** Returns the distance between this vector and `to`. */
+  /**
+   * Returns the Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+   */
   distance_to(to: Vector2i | Vector2): float;
   /** Returns the length (magnitude) of this vector. */
   length(): float;

package/typings/classes/Vector3.d.ts

@@ -56,11 +56,13 @@ declare interface Vector3 {
    */
   direction_to(to: Vector3 | Vector3i): Vector3;
   /**
-   * Returns the squared distance between this vector and `to`.
+   * Returns the squared Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
    * This method runs faster than {@link distance_to}, so prefer it if you need to compare vectors or need the squared distance for some formula.
    */
   distance_squared_to(to: Vector3 | Vector3i): float;
-  /** Returns the distance between this vector and `to`. */
+  /**
+   * Returns the Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+   */
   distance_to(to: Vector3 | Vector3i): float;
   /**
    * Returns the dot product of this vector and `with`. This can be used to compare the angle between two vectors. For example, this can be used to determine whether an enemy is facing the player.

package/typings/classes/Vector3i.d.ts

@@ -21,11 +21,13 @@ declare interface Vector3i {
    */
   clampi(min: int, max: int): Vector3i;
   /**
-   * Returns the squared distance between this vector and `to`.
+   * Returns the squared Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
    * This method runs faster than {@link distance_to}, so prefer it if you need to compare vectors or need the squared distance for some formula.
    */
   distance_squared_to(to: Vector3i | Vector3): int;
-  /** Returns the distance between this vector and `to`. */
+  /**
+   * Returns the Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+   */
   distance_to(to: Vector3i | Vector3): float;
   /** Returns the length (magnitude) of this vector. */
   length(): float;

package/typings/classes/Vector4.d.ts

@@ -38,11 +38,13 @@ declare interface Vector4 {
    */
   direction_to(to: Vector4 | Vector4i): Vector4;
   /**
-   * Returns the squared distance between this vector and `to`.
+   * Returns the squared Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
    * This method runs faster than {@link distance_to}, so prefer it if you need to compare vectors or need the squared distance for some formula.
    */
   distance_squared_to(to: Vector4 | Vector4i): float;
-  /** Returns the distance between this vector and `to`. */
+  /**
+   * Returns the Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+   */
   distance_to(to: Vector4 | Vector4i): float;
   /** Returns the dot product of this vector and `with`. */
   dot(with_: Vector4 | Vector4i): float;

package/typings/classes/Vector4i.d.ts

@@ -23,11 +23,13 @@ declare interface Vector4i {
    */
   clampi(min: int, max: int): Vector4i;
   /**
-   * Returns the squared distance between this vector and `to`.
+   * Returns the squared Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
    * This method runs faster than {@link distance_to}, so prefer it if you need to compare vectors or need the squared distance for some formula.
    */
   distance_squared_to(to: Vector4i | Vector4): int;
-  /** Returns the distance between this vector and `to`. */
+  /**
+   * Returns the Euclidean distance (https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+   */
   distance_to(to: Vector4i | Vector4): float;
   /** Returns the length (magnitude) of this vector. */
   length(): float;

package/typings/classes/Viewport.d.ts

@@ -57,6 +57,7 @@ declare class Viewport extends Node {
   /**
    * The automatic LOD bias to use for meshes rendered within the {@link Viewport} (this is analogous to {@link ReflectionProbe.mesh_lod_threshold}). Higher values will use less detailed versions of meshes that have LOD variations generated. If set to `0.0`, automatic LOD is disabled. Increase {@link mesh_lod_threshold} to improve performance at the cost of geometry detail.
    * To control this property on the root viewport, set the {@link ProjectSettings.rendering/mesh_lod/lod_change/threshold_pixels} project setting.
+   * **Note:** Depending on the mesh's attributes (vertex colors, blend shapes, ...), a mesh may have fewer levels of LOD generated to avoid visible distortion of the mesh once it is affected by vertex colors or blend shapes. Meshes with a very low vertex count will also not have any LODs generated, which means this setting will not affect them at all. In general, this setting makes the largest impact on static meshes with a high vertex count.
    * **Note:** {@link mesh_lod_threshold} does not affect {@link GeometryInstance3D} visibility ranges (also known as "manual" LOD or hierarchical LOD).
    */
   mesh_lod_threshold: float;
@@ -151,8 +152,9 @@ declare class Viewport extends Node {
   /**
    * Affects the final texture sharpness by reading from a lower or higher mipmap (also called "texture LOD bias"). Negative values make mipmapped textures sharper but grainier when viewed at a distance, while positive values make mipmapped textures blurrier (even when up close).
    * Enabling temporal antialiasing ({@link use_taa}) will automatically apply a `-0.5` offset to this value, while enabling FXAA ({@link screen_space_aa}) will automatically apply a `-0.25` offset to this value. If both TAA and FXAA are enabled at the same time, an offset of `-0.75` is applied to this value.
-   * **Note:** If {@link scaling_3d_scale} is lower than `1.0` (exclusive), {@link texture_mipmap_bias} is used to adjust the automatic mipmap bias which is calculated internally based on the scale factor. The formula for this is `log2(scaling_3d_scale) + mipmap_bias`.
    * To control this property on the root viewport, set the {@link ProjectSettings.rendering/textures/default_filters/texture_mipmap_bias} project setting.
+   * **Note:** If {@link scaling_3d_scale} is lower than `1.0` (exclusive), {@link texture_mipmap_bias} is used to adjust the automatic mipmap bias which is calculated internally based on the scale factor. The formula for this is `log2(scaling_3d_scale) + mipmap_bias`.
+   * **Note:** This property is only supported in the Forward+ and Mobile renderers, not Compatibility. In Compatibility, this property is always treated as if it was set to `0.0`.
    */
   texture_mipmap_bias: float;
   /**
@@ -530,6 +532,11 @@ declare class Viewport extends Node {
    * **Note:** Only supported when the Metal rendering driver is in use, which limits this scaling mode to macOS and iOS.
    */
   static readonly SCALING_3D_MODE_METALFX_TEMPORAL: int;
+  /**
+   * Use nearest-neighbor filtering for the viewport's 3D buffer. This looks crisper than {@link SCALING_3D_MODE_BILINEAR} and has no additional rendering cost. The amount of scaling can be set using {@link scaling_3d_scale}. Values greater than `1.0` are not supported and bilinear downsampling will be used instead. A value of `1.0` disables scaling.
+   * **Note:** When using the **Nearest** scaling mode, to avoid uneven pixel scaling, it's highly recommended to use a value equal to an integer divisor with a dividend of `1`. For example, it's best to use a scale of `0.5` (1/2), `0.3333` (1/3), `0.25` (1/4), `0.2` (1/5), and so on.
+   */
+  static readonly SCALING_3D_MODE_NEAREST: int;
   /** Represents the size of the {@link Scaling3DMode} enum. */
   static readonly SCALING_3D_MODE_MAX: int;
   // enum MSAA
@@ -613,6 +620,7 @@ declare class Viewport extends Node {
   /**
    * Objects are displayed as wireframe models.
    * **Note:** {@link RenderingServer.set_debug_generate_wireframes} must be called before loading any meshes for wireframes to be visible when using the Compatibility renderer.
+   * **Note:** In the Compatibility renderer, backfaces are always visible when using wireframe rendering. In the Forward+ and Mobile renderers, wireframes follow the material's backface culling properties instead.
    */
   static readonly DEBUG_DRAW_WIREFRAME: int;
   /**
@@ -726,6 +734,16 @@ declare class Viewport extends Node {
    * **Note:** Only supported when using the Forward+ or Mobile rendering methods.
    */
   static readonly DEBUG_DRAW_INTERNAL_BUFFER: int;
+  /**
+   * Draws the cluster used by {@link AreaLight3D} nodes to optimize light rendering.
+   * **Note:** Only supported when using the Forward+ rendering method.
+   */
+  static readonly DEBUG_DRAW_CLUSTER_AREA_LIGHTS: int;
+  /**
+   * Draws the atlas used by {@link AreaLight3D} nodes in the upper left quadrant of the {@link Viewport}.
+   * **Note:** Only supported when using the Forward+ or Mobile rendering method.
+   */
+  static readonly DEBUG_DRAW_AREA_LIGHT_ATLAS: int;
   // enum DefaultCanvasItemTextureFilter
   /**
    * The texture filter reads from the nearest pixel only. This makes the texture look pixelated from up close, and grainy from a distance (due to mipmaps not being sampled).
@@ -745,6 +763,10 @@ declare class Viewport extends Node {
    * Use this for non-pixel art textures that may be viewed at a low scale (e.g. due to {@link Camera2D} zoom or sprite scaling), as mipmaps are important to smooth out pixels that are smaller than on-screen pixels.
    */
   static readonly DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS: int;
+  /**
+   * The {@link Viewport} will inherit the filter from its parent {@link CanvasItem} or {@link Viewport}.
+   */
+  static readonly DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_PARENT_NODE: int;
   /** Represents the size of the {@link DefaultCanvasItemTextureFilter} enum. */
   static readonly DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_MAX: int;
   // enum DefaultCanvasItemTextureRepeat
@@ -758,6 +780,10 @@ declare class Viewport extends Node {
   static readonly DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_ENABLED: int;
   /** Flip the texture when repeating so that the edge lines up instead of abruptly changing. */
   static readonly DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MIRROR: int;
+  /**
+   * The {@link Viewport} will inherit the repeat mode from its parent {@link CanvasItem} or {@link Viewport}.
+   */
+  static readonly DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_PARENT_NODE: int;
   /** Represents the size of the {@link DefaultCanvasItemTextureRepeat} enum. */
   static readonly DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MAX: int;
   // enum SDFOversize

package/typings/classes/VirtualJoystick.d.ts

@@ -0,0 +1,94 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A virtual joystick control for touchscreen devices. */
+declare class VirtualJoystick extends Control {
+  /** The action to trigger when the joystick is moved down. */
+  action_down: string;
+  /** The action to trigger when the joystick is moved left. */
+  action_left: string;
+  /** The action to trigger when the joystick is moved right. */
+  action_right: string;
+  /** The action to trigger when the joystick is moved up. */
+  action_up: string;
+  /**
+   * The multiplier applied to the joystick's radius that defines the clamp zone.
+   * This zone limits how far the joystick tip can move from its center before being clamped.
+   * A value of `1.0` means the tip can move up to the edge of the joystick's visual size.
+   * In {@link JOYSTICK_FOLLOWING} mode, this radius also determines how far the finger can move before the joystick base starts following the touch input.
+   */
+  clampzone_ratio: float;
+  /**
+   * The ratio of the joystick size that defines the joystick deadzone. The joystick tip must move beyond this ratio before being considered active.
+   * This deadzone is applied before triggering input actions and affects the joystick's input vector and all related signals.
+   * Note that input actions may also define their own deadzones in the InputMap. If both are set, the joystick deadzone is applied first, followed by the action's deadzone.
+   * By default, this value is `0.0`, meaning the joystick does not apply its own deadzone and relies entirely on the InputMap action deadzones.
+   */
+  deadzone_ratio: float;
+  /**
+   * The initial position of the joystick as a ratio of the control's size. `(0, 0)` is top-left and `(1, 1)` is bottom-right.
+   */
+  initial_offset_ratio: Vector2;
+  /** The joystick mode to use. */
+  joystick_mode: int;
+  /** The size of the joystick in pixels. */
+  joystick_size: float;
+  /** The size of the joystick tip in pixels. */
+  tip_size: float;
+  /** The visibility mode to use. */
+  visibility_mode: int;
+  set_action_down(value: string): void;
+  get_action_down(): string;
+  set_action_left(value: string): void;
+  get_action_left(): string;
+  set_action_right(value: string): void;
+  get_action_right(): string;
+  set_action_up(value: string): void;
+  get_action_up(): string;
+  set_clampzone_ratio(value: float): void;
+  get_clampzone_ratio(): float;
+  set_deadzone_ratio(value: float): void;
+  get_deadzone_ratio(): float;
+  set_initial_offset_ratio(value: Vector2 | Vector2i): void;
+  get_initial_offset_ratio(): Vector2;
+  set_joystick_mode(value: int): void;
+  get_joystick_mode(): int;
+  set_joystick_size(value: float): void;
+  get_joystick_size(): float;
+  set_tip_size(value: float): void;
+  get_tip_size(): float;
+  set_visibility_mode(value: int): void;
+  get_visibility_mode(): int;
+
+  /** Emitted when the tip enters the deadzone after being outside of it. */
+  flick_canceled: Signal<[]>;
+  /**
+   * Emitted when the tip moved outside the deadzone and the joystick is released. The `input_vector` contains the last input direction and strength before release. Its length is between `0.0` and `1.0`.
+   */
+  flicked: Signal<[Vector2]>;
+  /** Emitted when the joystick is pressed. */
+  pressed: Signal<[]>;
+  /**
+   * Emitted when the joystick is released. The `input_vector` is the final input direction and strength, with a length between `0.0` and `1.0`.
+   */
+  released: Signal<[Vector2]>;
+  /** Emitted when the joystick is released without moving the tip. */
+  tapped: Signal<[]>;
+
+  // enum JoystickMode
+  /** The joystick doesn't move. */
+  static readonly JOYSTICK_FIXED: int;
+  /**
+   * The joystick is moved to the initial touch position as long as it's within the joystick's bounds. It moves back to its original position when released.
+   */
+  static readonly JOYSTICK_DYNAMIC: int;
+  /**
+   * The joystick is moved to the initial touch position as long as it's within the joystick's bounds. It will follow the touch input if it goes outside the joystick's range. It moves back to its original position when released.
+   */
+  static readonly JOYSTICK_FOLLOWING: int;
+  // enum VisibilityMode
+  /** The joystick is always visible. */
+  static readonly VISIBILITY_ALWAYS: int;
+  /** The joystick is only visible when being touched. */
+  static readonly VISIBILITY_WHEN_TOUCHED: int;
+}

package/typings/classes/VoxelGIData.d.ts

@@ -46,15 +46,25 @@ declare class VoxelGIData extends Resource {
   set_use_two_bounces(value: boolean): void;
   is_using_two_bounces(): boolean;
 
+  /**
+   * Initializes this {@link VoxelGIData} with the specified data. `octree_cells` must be a multiple of 32. `octree_cells` must be double the size of `data_cells`. The allocated data can be retrieved later using the various getter methods.
+   */
   allocate(to_cell_xform: Transform3D | Projection, aabb: AABB, octree_size: Vector3 | Vector3i, octree_cells: PackedByteArray | Array<unknown>, data_cells: PackedByteArray | Array<unknown>, distance_field: PackedByteArray | Array<unknown>, level_counts: PackedInt32Array | Array<unknown>): void;
   /**
    * Returns the bounds of the baked voxel data as an {@link AABB}, which should match {@link VoxelGI.size} after being baked (which only contains the size as a {@link Vector3}).
    * **Note:** If the size was modified without baking the VoxelGI data, then the value of {@link get_bounds} and {@link VoxelGI.size} will not match.
    */
   get_bounds(): AABB;
+  /** Returns the baked cell data for this {@link VoxelGIData}. */
   get_data_cells(): PackedByteArray;
+  /** Returns the baked level counts for this {@link VoxelGIData}. */
   get_level_counts(): PackedInt32Array;
+  /** Returns the baked octree cell data for this {@link VoxelGIData}. */
   get_octree_cells(): PackedByteArray;
+  /**
+   * Returns the baked octree size for this {@link VoxelGIData}, which corresponds to the number of subdivisions per axis. This can be viewed in the editor by hovering the **Bake VoxelGI** button at the top of the 3D editor viewport when a {@link VoxelGI} node is selected and looking at the **Subdivisions** field in the tooltip.
+   */
   get_octree_size(): Vector3;
+  /** Returns the baked cell transform for this {@link VoxelGIData}. */
   get_to_cell_xform(): Transform3D;
 }