typescript-to-gdscript 0.1.1 → 0.1.2

package/typings/classes/EditorSpinSlider.d.ts

@@ -5,6 +5,10 @@
 declare class EditorSpinSlider extends Range {
   /** The state in which the control used to manipulate the value will be. */
   control_state: int;
+  /**
+   * If `true`, changing via dragging is applied only at the end of the input (for example, when the user releases a mouse button).
+   */
+  deferred_drag_mode: boolean;
   /**
    * If `true`, the {@link EditorSpinSlider} is considered to be editing an integer value. If `false`, the {@link EditorSpinSlider} is considered to be editing a floating-point value. This is used to determine whether a slider should be drawn by default. The slider is only drawn for floats; integers use up-down arrows similar to {@link SpinBox} instead, unless {@link control_state} is set to {@link CONTROL_STATE_PREFER_SLIDER}. It will also use {@link EditorSettings.interface/inspector/integer_drag_speed} instead of {@link EditorSettings.interface/inspector/float_drag_speed} if the slider is available.
    */
@@ -28,6 +32,8 @@ declare class EditorSpinSlider extends Range {
   size_flags_vertical: int;
   set_control_state(value: int): void;
   get_control_state(): int;
+  set_deferred_drag_mode_enabled(value: boolean): void;
+  is_deferred_drag_mode_enabled(): boolean;
   set_editing_integer(value: boolean): void;
   is_editing_integer(): boolean;
   set_flat(value: boolean): void;

package/typings/classes/EditorTranslationParserPlugin.d.ts

@@ -5,6 +5,10 @@
  * Plugin for adding custom parsers to extract strings that are to be translated from custom files (.csv, .json etc.).
  */
 declare class EditorTranslationParserPlugin extends RefCounted {
+  /**
+   * Called after parsing all files. You can modify the `strings` array to add or remove entries from the final list of strings, then return it after modifications. Each entry is a {@link PackedStringArray} like explained in the {@link EditorTranslationParserPlugin}'s description.
+   */
+  _customize_strings(strings: Array<PackedStringArray>): Array<PackedStringArray>;
   /** Gets the list of file extensions to associate with this parser, e.g. `["csv"]`. */
   _get_recognized_extensions(): PackedStringArray;
   /** Override this method to define a custom parsing logic to extract the translatable strings. */

package/typings/classes/EditorVCSInterface.d.ts

@@ -3,10 +3,14 @@
 
 /** Version Control System (VCS) interface, which reads and writes to the local VCS in use. */
 declare class EditorVCSInterface extends GodotObject {
+  /** Returns whether or not the plugin allows commit amends. */
+  _allow_amends(): boolean;
   /** Checks out a `branch_name` in the VCS. */
   _checkout_branch(branch_name: string | NodePath): boolean;
-  /** Commits the currently staged changes and applies the commit `msg` to the resulting commit. */
-  _commit(msg: string | NodePath): void;
+  /**
+   * Commits the currently staged changes and applies the commit `msg` to the resulting commit. If `amend` is `true` the commit will modify the most recent commit instead.
+   */
+  _commit(msg: string | NodePath, amend: boolean): void;
   /** Creates a new branch named `branch_name` in the VCS. */
   _create_branch(branch_name: string | NodePath): void;
   /**

package/typings/classes/Environment.d.ts

@@ -11,6 +11,7 @@ declare class Environment extends Resource {
   adjustment_brightness: float;
   /**
    * The {@link Texture2D} or {@link Texture3D} lookup table (LUT) to use for the built-in post-process color grading. Can use a {@link GradientTexture1D} for a 1-dimensional LUT, or a {@link Texture3D} for a more complex LUT. Effective only if {@link adjustment_enabled} is `true`.
+   * **Note:** Color correction does not currently support HDR output due to only supporting values in the SDR (0.0 to 1.0) range.
    */
   adjustment_color_correction: Texture | null;
   /**
@@ -345,7 +346,7 @@ declare class Environment extends Resource {
   tonemap_agx_contrast: float;
   /**
    * The white reference value for tonemapping, which indicates where bright white is located in the scale of values provided to the tonemapper. For photorealistic lighting, it is recommended to set {@link tonemap_agx_white} to at least `6.0`. Higher values result in less blown out highlights, but may make the scene appear lower contrast. {@link tonemap_agx_white} is the same as {@link tonemap_white}, but is only effective with the {@link TONE_MAPPER_AGX} tonemapper. See also {@link tonemap_exposure}.
-   * **Note:** When using the Mobile renderer with {@link Viewport.use_hdr_2d} disabled, {@link tonemap_agx_white} is ignored and a white value of `2.0` will always be used instead.
+   * **Note:** When using the Mobile renderer with {@link Viewport.use_hdr_2d} disabled, {@link tonemap_agx_white} is ignored and a white value of `2.0` will always be used instead. Otherwise, {@link tonemap_agx_white} will be dynamically adjusted at runtime by multiplying it by the parent window's {@link Window.get_output_max_linear_value} when using {@link Viewport.use_hdr_2d} to ensure good behavior with both SDR and HDR output.
    */
   tonemap_agx_white: float;
   /**
@@ -360,6 +361,7 @@ declare class Environment extends Resource {
   /**
    * The white reference value for tonemapping, which indicates where bright white is located in the scale of values provided to the tonemapper. For photorealistic lighting, it is recommended to set {@link tonemap_white} to at least `6.0`. Higher values result in less blown out highlights, but may make the scene appear lower contrast. {@link tonemap_agx_white} will be used instead when using the {@link TONE_MAPPER_AGX} tonemapper. See also {@link tonemap_exposure}.
    * **Note:** {@link tonemap_white} must be set to `2.0` or lower on the Mobile renderer to produce bright images.
+   * **Note:** {@link tonemap_white} is ignored when using {@link TONE_MAPPER_LINEAR} and will be dynamically adjusted at runtime to never be less than the parent window's {@link Window.get_output_max_linear_value} when using {@link TONE_MAPPER_REINHARDT} with {@link Viewport.use_hdr_2d}.
    */
   tonemap_white: float;
   /**
@@ -662,11 +664,13 @@ declare class Environment extends Resource {
   static readonly TONE_MAPPER_REINHARDT: int;
   /**
    * Uses a film-like tonemapping curve to prevent clipping of bright values and provide better contrast than {@link TONE_MAPPER_REINHARDT}. Slightly slower than {@link TONE_MAPPER_REINHARDT}.
+   * **Note:** This tonemapper does not support HDR output because it produces output in the SDR range. It is recommended to use a different tonemapper when rendering to an HDR screen.
    */
   static readonly TONE_MAPPER_FILMIC: int;
   /**
    * Uses a high-contrast film-like tonemapping curve and desaturates bright values for a more realistic appearance. Slightly slower than {@link TONE_MAPPER_FILMIC}.
    * **Note:** This tonemapping operator is called "ACES Fitted" in Godot 3.x.
+   * **Note:** This tonemapper does not support HDR output because it produces output in the SDR range. It is recommended to use a different tonemapper when rendering to an HDR screen.
    */
   static readonly TONE_MAPPER_ACES: int;
   /**
@@ -677,11 +681,12 @@ declare class Environment extends Resource {
   /** Adds the glow effect to the scene. */
   static readonly GLOW_BLEND_MODE_ADDITIVE: int;
   /**
-   * Adds the glow effect to the scene after modifying the glow influence based on the scene value; dark values will be highly influenced by glow and bright values will not be influenced by glow. This approach avoids bright values becoming overly bright from the glow effect. {@link tonemap_white} is used to determine the maximum scene value where the glow should have no influence. When {@link tonemap_mode} is set to {@link TONE_MAPPER_LINEAR}, a value of `1.0` will be used as the maximum scene value.
+   * Adds the glow effect to the scene after modifying the glow influence based on the scene value; dark values will be highly influenced by glow and bright values will not be influenced by glow. This approach avoids bright values becoming overly bright from the glow effect. {@link tonemap_white} is used to determine the maximum scene value where the glow should have no influence. When {@link tonemap_mode} is set to {@link TONE_MAPPER_LINEAR} and {@link Viewport.use_hdr_2d} is `true`, the parent window's {@link Window.get_output_max_linear_value} will be used as the maximum scene value.
    */
   static readonly GLOW_BLEND_MODE_SCREEN: int;
   /**
    * Adds the glow effect to the tonemapped image after modifying the glow influence based on the image value; dark values and bright values will not be influenced by glow and mid-range values will be highly influenced by glow. This approach avoids bright values becoming overly bright from the glow effect. The glow will have the largest influence on image values of `0.25` and will have no influence when applied to image values greater than `1.0`.
+   * **Note:** This blend mode does not support HDR output because expects a maximum output value of `1.0`. It is recommended to use a different blend mode when rendering to an HDR screen.
    */
   static readonly GLOW_BLEND_MODE_SOFTLIGHT: int;
   /**

package/typings/classes/FileAccess.d.ts

@@ -236,7 +236,7 @@ declare class FileAccess extends RefCounted {
   seek(position: int): void;
   /**
    * Sets the file cursor to the specified position in bytes, from the end of the file. This changes the value returned by {@link get_position}.
-   * **Note:** This is an offset, so you should use negative numbers otherwise the file cursor will be at the end of the file.
+   * **Note:** This is an offset, so you should use negative numbers otherwise the file cursor will move past the end of the file.
    */
   seek_end(position?: int): void;
   /**

package/typings/classes/FileDialog.d.ts

@@ -58,6 +58,21 @@ declare class FileDialog extends ConfirmationDialog {
   mode_overrides_title: boolean;
   /** The number of additional {@link OptionButton}s and {@link CheckBox}es in the dialog. */
   option_count: int;
+  /**
+   * The default value for the option at `index`.
+   * **Note:** `index` is a value in the `0 .. option_count - 1` range.
+   */
+  'option_{index}/default': int;
+  /**
+   * The name of the option at `index`.
+   * **Note:** `index` is a value in the `0 .. option_count - 1` range.
+   */
+  'option_{index}/name': string;
+  /**
+   * The list of values for the option at `index`.
+   * **Note:** `index` is a value in the `0 .. option_count - 1` range.
+   */
+  'option_{index}/values': PackedStringArray;
   /** If `true`, the {@link FileDialog} will warn the user before overwriting files in save mode. */
   overwrite_warning_enabled: boolean;
   /** If `true`, shows the recent directories list on the left side of the dialog. */
@@ -76,7 +91,7 @@ declare class FileDialog extends ConfirmationDialog {
    * <member name="title" type="String" setter="set_title" getter="get_title" overrides="Window" default="&quot;Save a File&quot;" />
    * <member name="use_native_dialog" type="bool" setter="set_use_native_dialog" getter="get_use_native_dialog" default="false">
    * If `true`, and if supported by the current {@link DisplayServer}, OS native dialog will be used instead of custom one.
-   * **Note:** On Android, it is only supported for Android 10+ devices and when using {@link ACCESS_FILESYSTEM}. For access mode {@link ACCESS_RESOURCES} and {@link ACCESS_USERDATA}, the system will fall back to custom FileDialog.
+   * **Note:** On Android, it is only supported when using {@link ACCESS_FILESYSTEM}. For access mode {@link ACCESS_RESOURCES} and {@link ACCESS_USERDATA}, the system will fall back to custom FileDialog.
    * **Note:** On Linux and macOS, sandboxed apps always use native dialogs to access the host file system.
    * **Note:** On macOS, sandboxed apps will save security-scoped bookmarks to retain access to the opened folders across multiple sessions. Use {@link OS.get_granted_permissions} to get a list of saved bookmarks.
    * **Note:** Native dialogs are isolated from the base process, file dialog properties can't be modified once the dialog is shown.

package/typings/classes/FoldableContainer.d.ts

@@ -8,7 +8,7 @@ declare class FoldableContainer extends Container {
    * The {@link FoldableGroup} associated with the container. When multiple {@link FoldableContainer} nodes share the same group, only one of them is allowed to be unfolded.
    */
   focus_mode: int;
-  /** If `true`, the container will becomes folded and will hide all its children. */
+  /** If `true`, the container will become folded and will hide all its children. */
   folded: boolean;
   /** Language code used for text shaping algorithms. If left empty, the current locale is used instead. */
   language: string;

package/typings/classes/Font.d.ts

@@ -42,9 +42,9 @@ declare class Font extends Resource {
    */
   draw_string_outline(canvas_item: RID, pos: Vector2 | Vector2i, text: string | NodePath, alignment: int, width?: float, font_size?: int, size?: int, modulate?: Color, justification_flags?: int, direction?: int, orientation?: int, oversampling?: float): void;
   /** Returns {@link TextServer} RID of the font cache for specific variation. */
-  find_variation(variation_coordinates: Dictionary, face_index?: int, strength?: float, transform?: Transform2D, spacing_top?: int, spacing_bottom?: int, spacing_space?: int, spacing_glyph?: int, baseline_offset?: float): RID;
+  find_variation(variation_coordinates: Dictionary, face_index?: int, strength?: float, transform?: Transform2D, spacing_top?: int, spacing_bottom?: int, spacing_space?: int, spacing_glyph?: int, baseline_offset?: float, palette_index?: int, custom_colors?: PackedColorArray | Array<unknown>): RID;
   /**
-   * Returns the average font ascent (number of pixels above the baseline).
+   * Returns the maximum font ascent (number of pixels above the baseline) of this font and all fallback fonts.
    * **Note:** Real ascent of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate (e.g. as the ascent of empty line).
    */
   get_ascent(font_size?: int): float;
@@ -54,7 +54,7 @@ declare class Font extends Resource {
    */
   get_char_size(char: int, font_size: int): Vector2;
   /**
-   * Returns the average font descent (number of pixels below the baseline).
+   * Returns the maximum font descent (number of pixels below the baseline) of this font and all fallback fonts.
    * **Note:** Real descent of the string is context-dependent and can be significantly different from the value returned by this function. Use it only as rough estimate (e.g. as the descent of empty line).
    */
   get_descent(font_size?: int): float;
@@ -92,6 +92,18 @@ declare class Font extends Resource {
    * Returns {@link Dictionary} with OpenType font name strings (localized font names, version, description, license information, sample text, etc.).
    */
   get_ot_name_strings(): Dictionary;
+  /**
+   * 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 FontVariation}.
+   */
+  get_palette_colors(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.
+   */
+  get_palette_count(): int;
+  /**
+   * 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.
+   */
+  get_palette_name(index: int): string;
   /**
    * Returns {@link Array} of valid {@link Font} {@link RID}s, which can be passed to the {@link TextServer} methods.
    */

package/typings/classes/FontVariation.d.ts

@@ -11,6 +11,12 @@ declare class FontVariation extends Font {
    * A set of OpenType feature tags. More info: OpenType feature tags (https://docs.microsoft.com/en-us/typography/opentype/spec/featuretags).
    */
   opentype_features: Dictionary;
+  /**
+   * An array of colors to override predefined palette. Use `Color(0, 0, 0, 0)`, to keep predefined palette color at specific position.
+   */
+  palette_custom_colors: PackedColorArray;
+  /** A palette index. */
+  palette_index: int;
   /** Extra spacing at the bottom of the line in pixels. */
   spacing_bottom: int;
   /** Extra spacing between graphical glyphs. */
@@ -42,6 +48,10 @@ declare class FontVariation extends Font {
   set_baseline_offset(value: float): void;
   get_baseline_offset(): float;
   set_opentype_features(value: Dictionary): void;
+  set_palette_custom_colors(value: PackedColorArray | Array<unknown>): void;
+  get_palette_custom_colors(): PackedColorArray;
+  set_palette_index(value: int): void;
+  get_palette_index(): int;
   set_variation_embolden(value: float): void;
   get_variation_embolden(): float;
   set_variation_face_index(value: int): void;

package/typings/classes/GDScript.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A script implemented in the GDScript programming language. */
+declare class GDScript extends Script {
+  /** Returns a new instance of the script. */
+  new(...args: any[]): unknown;
+}

package/typings/classes/GDScriptLanguageProtocol.d.ts

@@ -0,0 +1,25 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** GDScript language server. */
+declare interface GDScriptLanguageProtocol extends JSONRPC {
+  /** Returns the language server's {@link GDScriptTextDocument} instance. */
+  get_text_document(): GDScriptTextDocument | null;
+  /** Returns the language server's {@link GDScriptWorkspace} instance. */
+  get_workspace(): GDScriptWorkspace | null;
+  initialize(params: Dictionary): unknown;
+  initialized(params: unknown): void;
+  /**
+   * Returns `true` if the language server was initialized by a language server client, `false` otherwise.
+   */
+  is_initialized(): boolean;
+  /**
+   * Returns `true` if the language server is providing the smart resolve feature, `false` otherwise. The feature can be configured through the editor settings.
+   */
+  is_smart_resolve_enabled(): boolean;
+  notify_client(method: string | NodePath, params?: unknown, client_id?: int): void;
+  on_client_connected(): int;
+  on_client_disconnected(client_id: int): void;
+}
+declare const GDScriptLanguageProtocol: GDScriptLanguageProtocol;
+

package/typings/classes/GDScriptSyntaxHighlighter.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A GDScript syntax highlighter that can be used with {@link TextEdit} and {@link CodeEdit} nodes. */
+declare class GDScriptSyntaxHighlighter extends EditorSyntaxHighlighter {
+}

package/typings/classes/GDScriptTextDocument.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Document related language server functionality. */
+declare class GDScriptTextDocument extends RefCounted {
+  codeLens(params: Dictionary): Array<unknown>;
+  colorPresentation(params: Dictionary): Array<unknown>;
+  completion(params: Dictionary): Array<unknown>;
+  declaration(params: Dictionary): unknown;
+  definition(params: Dictionary): Array<unknown>;
+  didChange(params: unknown): void;
+  didClose(params: unknown): void;
+  didOpen(params: unknown): void;
+  didSave(params: unknown): void;
+  documentLink(params: Dictionary): Array<unknown>;
+  documentSymbol(params: Dictionary): Array<unknown>;
+  foldingRange(params: Dictionary): Array<unknown>;
+  hover(params: Dictionary): unknown;
+  nativeSymbol(params: Dictionary): unknown;
+  prepareRename(params: Dictionary): unknown;
+  references(params: Dictionary): Array<unknown>;
+  rename(params: Dictionary): Dictionary;
+  resolve(params: Dictionary): Dictionary;
+  show_native_symbol_in_editor(symbol_id: string | NodePath): void;
+  signatureHelp(params: Dictionary): unknown;
+  willSaveWaitUntil(params: unknown): void;
+}

package/typings/classes/GDScriptWorkspace.d.ts

@@ -0,0 +1,17 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Workspace related language server functionality. */
+declare class GDScriptWorkspace extends RefCounted {
+  apply_new_signal(obj: GodotObject, function_: string | NodePath, args: PackedStringArray | Array<unknown>): void;
+  didDeleteFiles(params: Dictionary): void;
+  /** Returns the interface of the script in a machine-readable format. */
+  generate_script_api(path: string | NodePath): Dictionary;
+  /** Converts a URI to a file path. */
+  get_file_path(uri: string | NodePath): string;
+  /** Converts a file path to a URI. */
+  get_file_uri(path: string | NodePath): string;
+  parse_local_script(path: string | NodePath): int;
+  parse_script(path: string | NodePath, content: string | NodePath): int;
+  publish_diagnostics(path: string | NodePath): void;
+}

package/typings/classes/GPUParticles2D.d.ts

@@ -178,9 +178,9 @@ declare class GPUParticles2D extends Node2D {
   emit_particle(xform: Transform2D, velocity: Vector2 | Vector2i, color: Color, custom: Color, flags: int): void;
   /**
    * Requests the particles to process for extra process time during a single frame.
-   * Useful for particle playback, if used in combination with {@link use_fixed_seed} or by calling {@link restart} with parameter `keep_seed` set to `true`.
+   * `process_time` defines the time that the particles will process while emitting is on. `process_time_residual` defines the time that particles will process with emitting turned off for the simulation. When combined with {@link speed_scale} set to `0.0`, this is useful to be able to seek a particle system timeline.
    */
-  request_particles_process(process_time: float): void;
+  request_particles_process(process_time: float, process_time_residual?: float): void;
   /**
    * Restarts the particle emission cycle, clearing existing particles. To avoid particles vanishing from the viewport, wait for the {@link finished} signal before calling.
    * **Note:** The {@link finished} signal is only emitted by {@link one_shot} emitters.

package/typings/classes/GPUParticles3D.d.ts

@@ -101,7 +101,14 @@ declare class GPUParticles3D extends GeometryInstance3D {
    * The amount of time the particle's trail should represent (in seconds). Only effective if {@link trail_enabled} is `true`.
    */
   trail_lifetime: float;
+  /** The alignment of particles. Use this for billboarding and aligning to velocity. */
   transform_align: int;
+  /**
+   * When using transform align local billboard, which axis to use for the billboarding. Supports only X or Y.
+   */
+  transform_align_axis: int;
+  /** In the case of billboarded particles, which custom channel to read from to calculate their angle. */
+  transform_align_channel_filter: int;
   /**
    * If `true`, particles will use the same seed for every simulation using the seed defined in {@link seed}. This is useful for situations where the visual outcome should be consistent across replays, for example when using Movie Maker mode.
    */
@@ -160,6 +167,10 @@ declare class GPUParticles3D extends GeometryInstance3D {
   get_trail_lifetime(): float;
   set_transform_align(value: int): void;
   get_transform_align(): int;
+  set_transform_align_axis(value: int): void;
+  get_transform_align_axis(): int;
+  set_transform_align_channel_filter(value: int): void;
+  get_transform_align_channel_filter(): int;
   set_use_fixed_seed(value: boolean): void;
   get_use_fixed_seed(): boolean;
   set_visibility_aabb(value: AABB): void;
@@ -181,9 +192,9 @@ declare class GPUParticles3D extends GeometryInstance3D {
   get_draw_pass_mesh(pass: int): Mesh | null;
   /**
    * Requests the particles to process for extra process time during a single frame.
-   * Useful for particle playback, if used in combination with {@link use_fixed_seed} or by calling {@link restart} with parameter `keep_seed` set to `true`.
+   * `process_time` defines the time that the particles will process while emitting is on. `process_time_residual` defines the time that particles will process with emitting turned off for the simulation. When combined with {@link speed_scale} set to `0.0`, this is useful to be able to seek a particle system timeline.
    */
-  request_particles_process(process_time: float): void;
+  request_particles_process(process_time: float, process_time_residual?: float): void;
   /**
    * Restarts the particle emission cycle, clearing existing particles. To avoid particles vanishing from the viewport, wait for the {@link finished} signal before calling.
    * **Note:** The {@link finished} signal is only emitted by {@link one_shot} emitters.
@@ -225,10 +236,16 @@ declare class GPUParticles3D extends GeometryInstance3D {
   /** Particle starts with specified `CUSTOM` data. */
   static readonly EMIT_FLAG_CUSTOM: int;
   // enum TransformAlign
+  /** Do not align particle transforms relative to the camera or velocity. */
   static readonly TRANSFORM_ALIGN_DISABLED: int;
+  /** Align each particle's Z axis to face the camera. */
   static readonly TRANSFORM_ALIGN_Z_BILLBOARD: int;
+  /** Align each particle's Y axis to the velocity vector. */
   static readonly TRANSFORM_ALIGN_Y_TO_VELOCITY: int;
+  /** Align each particle's Z axis to face the camera and Y axis to the velocity vector. */
   static readonly TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY: int;
+  /** Align each particle's Z axis to face the camera, while preserving a given axis (X or Y). */
+  static readonly TRANSFORM_ALIGN_LOCAL_BILLBOARD: int;
 
   /** Maximum number of draw passes supported. */
   static readonly MAX_DRAW_PASSES: int;

package/typings/classes/Geometry2D.d.ts

@@ -66,7 +66,7 @@ declare interface Geometry2D extends GodotObject {
   is_polygon_clockwise(polygon: PackedVector2Array | Array<unknown>): boolean;
   /**
    * Returns the point of intersection between the two lines (`from_a`, `dir_a`) and (`from_b`, `dir_b`). Returns a {@link Vector2}, or `null` if the lines are parallel.
-   * `from` and `dir` are *not* endpoints of a line segment or ray but the slope (`dir`) and a known point (`from`) on that line.
+   * `from` and `dir` are *not* endpoints of a line segment or ray but the slope (`dir`) and a known point (`from`) on that line. To get the intersection between two line segments, use {@link segment_intersects_segment}.
    */
   line_intersects_line(from_a: Vector2 | Vector2i, dir_a: Vector2 | Vector2i, from_b: Vector2 | Vector2i, dir_b: Vector2 | Vector2i): unknown;
   /**
@@ -99,7 +99,7 @@ declare interface Geometry2D extends GodotObject {
    */
   segment_intersects_circle(segment_from: Vector2 | Vector2i, segment_to: Vector2 | Vector2i, circle_position: Vector2 | Vector2i, circle_radius: float): float;
   /**
-   * Checks if the two segments (`from_a`, `to_a`) and (`from_b`, `to_b`) intersect. If yes, return the point of intersection as {@link Vector2}. If no intersection takes place, returns `null`.
+   * Checks if two line segments intersect, with line `a` between `from_a` and `to_a` and line `b` between `from_b` and `to_b`. If the line segments intersect, the point of intersection is returned as a {@link Vector2}. If no intersection takes place, `null` is returned.
    */
   segment_intersects_segment(from_a: Vector2 | Vector2i, to_a: Vector2 | Vector2i, from_b: Vector2 | Vector2i, to_b: Vector2 | Vector2i): unknown;
   /**

package/typings/classes/GeometryInstance3D.d.ts

@@ -6,7 +6,7 @@ declare class GeometryInstance3D extends VisualInstance3D {
   /** The mode used to cast shadows from this instance. */
   cast_shadow: int;
   /**
-   * Overrides the bounding box of this node with a custom one. This can be used to avoid the expensive {@link AABB} recalculation that happens when a skeleton is used with a {@link MeshInstance3D} or to have precise control over the {@link MeshInstance3D}'s bounding box. To use the default AABB, set value to an {@link AABB} with all fields set to `0.0`. To avoid frustum culling, set {@link custom_aabb} to a very large AABB that covers your entire game world such as `AABB(-10000, -10000, -10000, 20000, 20000, 20000)`. To disable all forms of culling (including occlusion culling), call {@link RenderingServer.instance_set_ignore_culling} on the {@link GeometryInstance3D}'s {@link RID}.
+   * Overrides the bounding box of this node with a custom one. This can be used to avoid the expensive {@link AABB} recalculation that happens when a skeleton is used with a {@link MeshInstance3D} or to have precise control over the {@link MeshInstance3D}'s bounding box. To use the default AABB, set value to an {@link AABB} with all fields set to `0.0`. To avoid frustum culling, set {@link custom_aabb} to a very large AABB that covers your entire game world such as `AABB(-10000, -10000, -10000, 20000, 20000, 20000)`. To disable all forms of culling (including occlusion and layer culling), call {@link RenderingServer.instance_set_ignore_culling} on the {@link GeometryInstance3D}'s {@link RID}.
    */
   custom_aabb: AABB;
   /**

package/typings/classes/GradientTexture2D.d.ts

@@ -46,6 +46,8 @@ declare class GradientTexture2D extends Texture2D {
   static readonly FILL_RADIAL: int;
   /** The colors are linearly interpolated in a square pattern. */
   static readonly FILL_SQUARE: int;
+  /** The colors are linearly interpolated in a cone pattern. */
+  static readonly FILL_CONIC: int;
   // enum Repeat
   /**
    * The gradient fill is restricted to the range defined by {@link fill_from} to {@link fill_to} offsets.

package/typings/classes/Image.d.ts

@@ -210,6 +210,7 @@ declare class Image extends Resource {
   premultiply_alpha(): void;
   /**
    * Resizes the image to the given `width` and `height`. New pixels are calculated using the `interpolation` mode defined via {@link Interpolation} constants.
+   * **Note:** If the image's format is {@link FORMAT_RGBA4444}, {@link FORMAT_RGB565}, or {@link FORMAT_RGBE9995}, it will be temporarily converted to either {@link FORMAT_RGBA8} or {@link FORMAT_RGBAH}. This can affect the quality of the resized image.
    */
   resize(width: int, height: int, interpolation: int): void;
   /**
@@ -237,13 +238,15 @@ declare class Image extends Resource {
    */
   save_dds_to_buffer(): PackedByteArray;
   /**
-   * Saves the image as an EXR file to `path`. If `grayscale` is `true` and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. This function will return {@link ERR_UNAVAILABLE} if Godot was compiled without the TinyEXR module.
+   * Saves the image as an EXR file to `path`. If `grayscale` is `true` and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. Set `color_image` to `true` when saving a color image, such as a screenshot. Negative values will be included when `color_image` is `false`, which may be useful for saving raw floating point data such as a lightmap that includes negative light information. Color component values in the resulting EXR file will not exceed `max_linear_value` if `max_linear_value` is not negative. This function will return {@link ERR_UNAVAILABLE} if Godot was compiled without the TinyEXR module.
+   * When saving screenshots of a project that uses HDR output, use {@link Window.get_output_max_linear_value} for `max_linear_value`.
    */
-  save_exr(path: string | NodePath, grayscale?: boolean): int;
+  save_exr(path: string | NodePath, grayscale?: boolean, color_image?: boolean, max_linear_value?: float): int;
   /**
-   * Saves the image as an EXR file to a byte array. If `grayscale` is `true` and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. This function will return an empty byte array if Godot was compiled without the TinyEXR module.
+   * Saves the image as an EXR file to a byte array. If `grayscale` is `true` and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. Set `color_image` to `true` when saving a color image, such as a screenshot. Negative values will be included when `color_image` is `false`, which may be useful for saving raw floating point data such as a lightmap that includes negative light information. Color component values in the resulting EXR file will not exceed `max_linear_value` if `max_linear_value` is not negative. This function will return an empty byte array if Godot was compiled without the TinyEXR module.
+   * When saving screenshots of a project that uses HDR output, use {@link Window.get_output_max_linear_value} for `max_linear_value`.
    */
-  save_exr_to_buffer(grayscale?: boolean): PackedByteArray;
+  save_exr_to_buffer(grayscale?: boolean, color_image?: boolean, max_linear_value?: float): PackedByteArray;
   /**
    * Saves the image as a JPEG file to `path` with the specified `quality` between `0.01` and `1.0` (inclusive). Higher `quality` values result in better-looking output at the cost of larger file sizes. Recommended `quality` values are between `0.75` and `0.90`. Even at quality `1.00`, JPEG compression remains lossy.
    * **Note:** JPEG does not save an alpha channel. If the {@link Image} contains an alpha channel, the image will still be saved, but the resulting JPEG file won't contain the alpha channel.

package/typings/classes/ImageFormatLoader.d.ts

@@ -5,7 +5,12 @@
 declare class ImageFormatLoader extends RefCounted {
 
   // enum LoaderFlags
+  /** Default loading behavior. No processing is applied to the image. */
   static readonly FLAG_NONE: int;
+  /** If set, the image is converted from sRGB to linear encoding. */
   static readonly FLAG_FORCE_LINEAR: int;
+  /**
+   * If set, a predefined color map is applied to the image. Used when {@link ResourceImporterTexture.editor/convert_colors_with_editor_theme} is `true`.
+   */
   static readonly FLAG_CONVERT_COLORS: int;
 }

package/typings/classes/ImageTexture.d.ts

@@ -9,8 +9,6 @@ declare class ImageTexture extends Texture2D {
    * Creates a new {@link ImageTexture} and initializes it by allocating and setting the data from an {@link Image}.
    */
   static create_from_image(image: Image): ImageTexture;
-  /** Returns the format of the texture. */
-  get_format(): int;
   /**
    * Replaces the texture's data with a new {@link Image}. This will re-allocate new memory for the texture.
    * If you want to update the image, but don't need to change its parameters (format, size), use {@link update} instead for better performance.

package/typings/classes/ImporterMesh.d.ts

@@ -67,6 +67,12 @@ declare class ImporterMesh extends Resource {
   get_surface_name(surface_idx: int): string;
   /** Returns the primitive type of the requested surface (see {@link add_surface}). */
   get_surface_primitive_type(surface_idx: int): int;
+  /**
+   * Merges multiple {@link ImporterMesh}es into a single {@link ImporterMesh}. Each input mesh is transformed by the corresponding {@link Transform3D} in the `relative_transforms` array, which must be the same size as `importer_meshes`. Negative scales are supported, and the winding order in the mesh data will be corrected to account for this.
+   * If `deduplicate_surfaces` is `true` and multiple meshes have surfaces with the same names and formats, the surfaces will be merged together when the meshes are merged, and will use the material from the first matching surface. This is useful for reducing the number of surfaces in the resulting mesh, and avoids duplicating materials. Surfaces with bone weights will never be deduplicated. If `deduplicate_surfaces` is `false`, the surfaces will always be kept separate, and will be given unique names.
+   * **Warning:** Blend shapes and LODs are not supported and will be discarded. Do not use this function to discard blend shapes and LODs, as support for these may be added in the future.
+   */
+  static merge_importer_meshes(importer_meshes: Array<ImporterMesh>, relative_transforms: Array<Transform3D>, deduplicate_surfaces?: boolean): ImporterMesh | null;
   /** Sets the blend shape mode. */
   set_blend_shape_mode(mode: int): void;
   /** Sets the size hint of this mesh for lightmap-unwrapping in UV-space. */