typescript-to-gdscript 0.1.0 → 0.1.2

package/typings/classes/PhysicsDirectSpaceState3DExtension.d.ts

@@ -5,12 +5,12 @@
  * Provides virtual methods that can be overridden to create custom {@link PhysicsDirectSpaceState3D} implementations.
  */
 declare class PhysicsDirectSpaceState3DExtension extends PhysicsDirectSpaceState3D {
-  _cast_motion(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, closest_safe: float, closest_unsafe: float, info: unknown): boolean;
-  _collide_shape(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, results: void, max_results: int, result_count: int): boolean;
+  _cast_motion(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, r_closest_safe: float, r_closest_unsafe: float, r_info: unknown): boolean;
+  _collide_shape(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, r_results: void, max_results: int, r_result_count: int): boolean;
   _get_closest_point_to_object_volume(object: RID, point: Vector3 | Vector3i): Vector3;
-  _intersect_point(position: Vector3 | Vector3i, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, results: unknown, max_results: int): int;
-  _intersect_ray(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, hit_from_inside: boolean, hit_back_faces: boolean, pick_ray: boolean, result: unknown): boolean;
-  _intersect_shape(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, result_count: unknown, max_results: int): int;
-  _rest_info(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, rest_info: unknown): boolean;
+  _intersect_point(position: Vector3 | Vector3i, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, r_results: unknown, max_results: int): int;
+  _intersect_ray(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, hit_from_inside: boolean, hit_back_faces: boolean, pick_ray: boolean, r_result: unknown): boolean;
+  _intersect_shape(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, r_result_count: unknown, max_results: int): int;
+  _rest_info(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, r_rest_info: unknown): boolean;
   is_body_excluded_from_query(body: RID): boolean;
 }

package/typings/classes/PhysicsServer2DExtension.d.ts

@@ -93,10 +93,10 @@ declare class PhysicsServer2DExtension extends PhysicsServer2D {
   /** Overridable version of {@link PhysicsServer2D.body_clear_shapes}. */
   _body_clear_shapes(body: RID): void;
   /**
-   * Given a `body`, a `shape`, and their respective parameters, this method should return `true` if a collision between the two would occur, with additional details passed in `results`.
+   * Given a `body`, a `shape`, and their respective parameters, this method should return `true` if a collision between the two would occur, with additional details passed in `r_results`.
    * Overridable version of {@link PhysicsServer2D}'s internal `shape_collide` method. Corresponds to {@link PhysicsDirectSpaceState2D.collide_shape}.
    */
-  _body_collide_shape(body: RID, body_shape: int, shape: RID, shape_xform: Transform2D, motion: Vector2 | Vector2i, results: void, result_max: int, result_count: int): boolean;
+  _body_collide_shape(body: RID, body_shape: int, shape: RID, shape_xform: Transform2D, motion: Vector2 | Vector2i, r_results: void, result_max: int, r_result_count: int): boolean;
   /** Overridable version of {@link PhysicsServer2D.body_create}. */
   _body_create(): RID;
   /** Overridable version of {@link PhysicsServer2D.body_get_canvas_instance_id}. */
@@ -205,7 +205,7 @@ declare class PhysicsServer2DExtension extends PhysicsServer2D {
   /**
    * Overridable version of {@link PhysicsServer2D.body_test_motion}. Unlike the exposed implementation, this method does not receive all of the arguments inside a {@link PhysicsTestMotionParameters2D}.
    */
-  _body_test_motion(body: RID, from_: Transform2D, motion: Vector2 | Vector2i, margin: float, collide_separation_ray: boolean, recovery_as_collision: boolean, result: unknown): boolean;
+  _body_test_motion(body: RID, from_: Transform2D, motion: Vector2 | Vector2i, margin: float, collide_separation_ray: boolean, recovery_as_collision: boolean, r_result: unknown): boolean;
   /** Overridable version of {@link PhysicsServer2D.capsule_shape_create}. */
   _capsule_shape_create(): RID;
   /** Overridable version of {@link PhysicsServer2D.circle_shape_create}. */
@@ -284,10 +284,10 @@ declare class PhysicsServer2DExtension extends PhysicsServer2D {
   /** Overridable version of {@link PhysicsServer2D.set_active}. */
   _set_active(active: boolean): void;
   /**
-   * Given two shapes and their parameters, should return `true` if a collision between the two would occur, with additional details passed in `results`.
+   * Given two shapes and their parameters, should return `true` if a collision between the two would occur, with additional details passed in `r_results`.
    * Overridable version of {@link PhysicsServer2D}'s internal `shape_collide` method. Corresponds to {@link PhysicsDirectSpaceState2D.collide_shape}.
    */
-  _shape_collide(shape_A: RID, xform_A: Transform2D, motion_A: Vector2 | Vector2i, shape_B: RID, xform_B: Transform2D, motion_B: Vector2 | Vector2i, results: void, result_max: int, result_count: int): boolean;
+  _shape_collide(shape_A: RID, xform_A: Transform2D, motion_A: Vector2 | Vector2i, shape_B: RID, xform_B: Transform2D, motion_B: Vector2 | Vector2i, r_results: void, result_max: int, r_result_count: int): boolean;
   /**
    * Should return the custom solver bias of the given `shape`, which defines how much bodies are forced to separate on contact when this shape is involved.
    * Overridable version of {@link PhysicsServer2D}'s internal `shape_get_custom_solver_bias` method. Corresponds to {@link Shape2D.custom_solver_bias}.

package/typings/classes/PhysicsServer3DExtension.d.ts

@@ -91,7 +91,7 @@ declare class PhysicsServer3DExtension extends PhysicsServer3D {
   _body_set_state(body: RID, state: int, value: unknown): void;
   _body_set_state_sync_callback(body: RID, callable: Callable): void;
   _body_set_user_flags(body: RID, flags: int): void;
-  _body_test_motion(body: RID, from_: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, max_collisions: int, collide_separation_ray: boolean, recovery_as_collision: boolean, result: unknown): boolean;
+  _body_test_motion(body: RID, from_: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, max_collisions: int, collide_separation_ray: boolean, recovery_as_collision: boolean, r_result: unknown): boolean;
   _box_shape_create(): RID;
   _capsule_shape_create(): RID;
   _concave_polygon_shape_create(): RID;

package/typings/classes/PopupMenu.d.ts

@@ -17,16 +17,64 @@ declare class PopupMenu extends Popup {
   hide_on_state_item_selection: boolean;
   /** The number of items currently in the list. */
   item_count: int;
+  /**
+   * The checkable item type of the item at `index`.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/checkable': int;
+  /**
+   * If `true`, the item at `index` is checked.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/checked': boolean;
+  /**
+   * If `true`, the item at `index` is disabled.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/disabled': boolean;
+  /**
+   * The icon of the item at `index`.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/icon': Texture2D | null;
+  /**
+   * The ID of the item at `index`.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/id': int;
+  /**
+   * If `true`, the item at `index` is a separator.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/separator': boolean;
+  /**
+   * The text of the item at `index`.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/text': string;
   /**
    * If `true`, {@link MenuBar} will use native menu when supported.
    * **Note:** If {@link PopupMenu} is linked to {@link StatusIndicator}, {@link MenuBar}, or another {@link PopupMenu} item it can use native menu regardless of this property, use {@link is_native_menu} to check it.
    */
   prefer_native_menu: boolean;
   /**
-   * Enables the {@link PopupMenu} search bar if the item count is greater than `0`.
+   * If `true`, shows a search bar at the top of the {@link PopupMenu} for filtering items. See {@link search_bar_min_item_count} for dynamically controlling its visibility based on the number of items.
    * **Note:** When enabled, {@link allow_search} is ignored.
    */
-  search_bar_enabled_on_item_count: int;
+  search_bar_enabled: boolean;
+  /**
+   * If `true`, enables fuzzy searching in the {@link PopupMenu} search bar. This allows the search results to include items that almost match the search query, as well items that match the individual characters of the search query, but not in sequence.
+   * Use {@link search_bar_fuzzy_search_max_misses} to set the maximum number of mismatches allowed in the search results.
+   */
+  search_bar_fuzzy_search_enabled: boolean;
+  /**
+   * Sets the maximum number of mismatches allowed in each search result when fuzzy searching is enabled for the {@link PopupMenu} search bar. Any item with more mismatches will be hidden from the search results.
+   */
+  search_bar_fuzzy_search_max_misses: int;
+  /**
+   * Sets the minimum number of items required for the search bar to be visible. {@link search_bar_enabled} must be `true` for this to have any effect. Separator items are not counted.
+   */
+  search_bar_min_item_count: int;
   /** If `true`, shrinks {@link PopupMenu} to minimum height when it's shown. */
   shrink_height: boolean;
   /** If `true`, shrinks {@link PopupMenu} to minimum width when it's shown. */
@@ -52,8 +100,14 @@ declare class PopupMenu extends Popup {
   get_item_count(): int;
   set_prefer_native_menu(value: boolean): void;
   is_prefer_native_menu(): boolean;
-  set_search_bar_enabled_on_item_count(value: int): void;
-  get_search_bar_enabled_on_item_count(): int;
+  set_search_bar_enabled(value: boolean): void;
+  is_search_bar_enabled(): boolean;
+  set_search_bar_fuzzy_search_enabled(value: boolean): void;
+  is_search_bar_fuzzy_search_enabled(): boolean;
+  set_search_bar_fuzzy_search_max_misses(value: int): void;
+  get_search_bar_fuzzy_search_max_misses(): int;
+  set_search_bar_min_item_count(value: int): void;
+  get_search_bar_min_item_count(): int;
   set_shrink_height(value: boolean): void;
   get_shrink_height(): boolean;
   set_shrink_width(value: boolean): void;
@@ -232,8 +286,6 @@ declare class PopupMenu extends Popup {
   is_item_shortcut_disabled(index: int): boolean;
   /** Returns `true` if the system native menu is supported and currently used by this {@link PopupMenu}. */
   is_native_menu(): boolean;
-  /** Returns `true` if search bar is currently enabled. */
-  is_search_bar_enabled(): boolean;
   /** Returns `true` if the menu is bound to the special system menu. */
   is_system_menu(): boolean;
   /**

package/typings/classes/ProjectSettings.d.ts

@@ -28,6 +28,10 @@ declare interface ProjectSettings {
    * If `true`, {@link AnimationMixer} prints the warning of interpolation being forced to choose the shortest rotation path due to multiple angle interpolation types being mixed in the {@link AnimationMixer} cache.
    */
   'animation/warnings/check_angle_interpolation_type_conflicting': boolean;
+  /**
+   * If `true`, {@link SkeletonModifier3D} prints a warning if there's no matching object for the track path in the scene when assigning.
+   */
+  'animation/warnings/check_invalid_skeleton_modifier_node_paths': boolean;
   /**
    * If `true`, {@link AnimationMixer} prints the warning of no matching object of the track path in the scene.
    */
@@ -343,6 +347,10 @@ declare interface ProjectSettings {
    * When set to **Warn** or **Error**, produces a warning or an error respectively when an identifier that will be shadowed below in the block is used.
    */
   'debug/gdscript/warnings/confusable_local_usage': int;
+  /**
+   * When set to **Warn** or **Error**, produces a warning or an error respectively when a built-in property of type `Packed*Array` is modified using a complex assignment chain or a non-`const` method call. In this case, you are only modifying a temporary value, and the property's value remains unchanged.
+   */
+  'debug/gdscript/warnings/confusable_temporary_modification': int;
   /**
    * When set to **Warn** or **Error**, produces a warning or an error respectively when deprecated keywords are used.
    * **Note:** There are currently no deprecated keywords, so this warning is never produced.
@@ -959,13 +967,13 @@ declare interface ProjectSettings {
    * `"keep"`: Keep aspect ratio when stretching the screen. This means that the viewport retains its original size regardless of the screen resolution, and black bars will be added to the top/bottom of the screen ("letterboxing") or the sides ("pillarboxing").
    * `"keep_width"`: Keep aspect ratio when stretching the screen. If the screen is wider than the base size, black bars are added at the left and right (pillarboxing). But if the screen is taller than the base resolution, the viewport will be grown in the vertical direction (and more content will be visible at the bottom). You can also think of this as "Expand Vertically".
    * `"keep_height"`: Keep aspect ratio when stretching the screen. If the screen is taller than the base size, black bars are added at the top and bottom (letterboxing). But if the screen is wider than the base resolution, the viewport will be grown in the horizontal direction (and more content will be visible to the right). You can also think of this as "Expand Horizontally".
-   * `"expand"`: Keep aspect ratio when stretching the screen, but keep neither the base width nor height. Depending on the screen aspect ratio, the viewport will either be larger in the horizontal direction (if the screen is wider than the base size) or in the vertical direction (if the screen is taller than the original size).
+   * `"expand"`: Keep aspect ratio when stretching the screen, but keep neither the base width nor height. Depending on the screen aspect ratio, the viewport will either be larger in the horizontal direction (if the screen is wider than the base size) or in the vertical direction (if the screen is taller than the original size). This is the default for projects created starting in Godot 4.7.
    */
   'display/window/stretch/aspect': string;
   /**
    * Defines how the base size is stretched to fit the resolution of the window or screen.
    * `"disabled"`: No stretching happens. One unit in the scene corresponds to one pixel on the screen. In this mode, {@link display/window/stretch/aspect} has no effect. Recommended for non-game applications.
-   * `"canvas_items"`: The base size specified in width and height in the project settings is stretched to cover the whole screen (taking {@link display/window/stretch/aspect} into account). This means that everything is rendered directly at the target resolution. 3D is unaffected, while in 2D, there is no longer a 1:1 correspondence between sprite pixels and screen pixels, which may result in scaling artifacts. Recommended for most games that don't use a pixel art aesthetic, although it is possible to use this stretch mode for pixel art games too (especially in 3D).
+   * `"canvas_items"`: The base size specified in width and height in the project settings is stretched to cover the whole screen (taking {@link display/window/stretch/aspect} into account). This means that everything is rendered directly at the target resolution. 3D is unaffected, while in 2D, there is no longer a 1:1 correspondence between sprite pixels and screen pixels, which may result in scaling artifacts. Recommended for most games that don't use a pixel art aesthetic, although it is possible to use this stretch mode for pixel art games too (especially in 3D). This is the default for projects created starting in Godot 4.7.
    * `"viewport"`: The size of the root {@link Viewport} is set precisely to the base size specified in the Project Settings' Display section. The scene is rendered to this viewport first. Finally, this viewport is scaled to fit the screen (taking {@link display/window/stretch/aspect} into account). Recommended for games that use a pixel art aesthetic.
    */
   'display/window/stretch/mode': string;
@@ -1144,10 +1152,10 @@ declare interface ProjectSettings {
    */
   'gui/common/drag_threshold': int;
   /**
-   * Determines whether a {@link Control} should visually indicate focus when said focus is gained using a mouse or touch input.
+   * Determines whether a {@link Control} should visually indicate focus when that focus is gained using a mouse or touch input.
    * - **Never** (`0`) show the focused state for mouse/touch input.
-   * - **Control Supports Keyboard Input** (`1`) shows the focused state even when gained via mouse/touch input (similar to how browsers handle focus).
-   * - **Always** (`2`) show the focused state, even if said focus was gained via mouse/touch input.
+   * - **Text Input Controls** (`1`) show the focused state even if that focus was gained via mouse/touch input (similar to browser behavior).
+   * - **Always** (`2`) show the focused state, even if that focus was gained via mouse/touch input.
    */
   'gui/common/show_focus_state_on_pointer_event': int;
   /**
@@ -1210,7 +1218,7 @@ declare interface ProjectSettings {
   /** LCD subpixel layout used for font anti-aliasing. See {@link TextServer.FontLCDSubpixelLayout}. */
   'gui/theme/lcd_subpixel_layout': int;
   /**
-   * When {@link BaseButton.shortcut_feedback} is enabled, this is the time the {@link BaseButton} will remain highlighted after a shortcut.
+   * When {@link BaseButton.shortcut_feedback} is enabled, this is the time the {@link BaseButton} will remain highlighted after a shortcut. This duration is not affected by {@link Engine.time_scale}.
    */
   'gui/timers/button_shortcut_feedback_highlight_time': float;
   /**
@@ -2816,6 +2824,10 @@ declare interface ProjectSettings {
    * {@link Environment} that will be used as a fallback environment in case a scene does not specify its own environment. The default environment is loaded in at scene load time regardless of whether you have set an environment or not. If you do not rely on the fallback environment, you do not need to set this property.
    */
   'rendering/environment/defaults/default_environment': string;
+  /**
+   * Enables legacy fog blending behavior from version 4.5 and earlier. This is intended for users who are developing on pre-4.6 versions and want to upgrade to 4.6 with the smallest possible change to their visuals.
+   */
+  'rendering/environment/fog/use_legacy_blending': boolean;
   /**
    * Sets how the glow effect is upscaled before being copied onto the screen. Linear is faster, but looks blocky. Bicubic is slower but looks smooth.
    * **Note:** {@link rendering/environment/glow/upscale_mode} is only effective when using the Forward+ or Mobile rendering methods, as Compatibility uses a different glow implementation.
@@ -3425,6 +3437,7 @@ declare interface ProjectSettings {
   'rendering/scaling_3d/mode.macos': int;
   /**
    * Scales the 3D render buffer based on the viewport size uses an image filter specified in {@link rendering/scaling_3d/mode} to scale the output image to the full viewport size. Values lower than `1.0` can be used to speed up 3D rendering at the cost of quality (undersampling). Values greater than `1.0` are only valid for bilinear mode and can be used to improve 3D rendering quality at a high performance cost (supersampling). See also {@link rendering/anti_aliasing/quality/msaa_3d} for multi-sample antialiasing, which is significantly cheaper but only smooths the edges of polygons.
+   * **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.
    */
   'rendering/scaling_3d/scale': float;
   'rendering/shader_compiler/shader_cache/compress': boolean;
@@ -3483,6 +3496,7 @@ declare interface ProjectSettings {
    * 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 rendering/anti_aliasing/quality/use_taa}) will automatically apply a `-0.5` offset to this value, while enabling FXAA ({@link rendering/anti_aliasing/quality/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 rendering/scaling_3d/scale} is lower than `1.0` (exclusive), {@link rendering/textures/default_filters/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`.
    */
   'rendering/textures/default_filters/texture_mipmap_bias': float;
   /**
@@ -3674,11 +3688,20 @@ declare interface ProjectSettings {
    * If `true` and foveation is supported, will automatically adjust foveation level based on framerate up to the level set on {@link xr/openxr/foveation_level}.
    */
   'xr/openxr/foveation_dynamic': boolean;
+  /**
+   * If `true` and foveation level is set to anything other than "Disabled", eye-tracked foveation will be used, so long as it's supported by the headset.
+   */
+  'xr/openxr/foveation_eye_tracked': boolean;
   /**
    * Applied foveation level if supported.
    * **Note:** On platforms other than Android, if {@link rendering/anti_aliasing/quality/msaa_3d} is enabled, this feature will be disabled.
    */
   'xr/openxr/foveation_level': int;
+  /**
+   * If `true` and foveation is also enabled, subsampled images will be used on Vulkan. This can improve the performance gain from foveated rendering, especially when using high foveation levels.
+   * **Note:**: Using subsampled images is incompatible with many screen-space rendering features or post-processing effects like FXAA or glow. If any such effects are enabled, subsampled images will automatically be disabled and a warning shown in the log.
+   */
+  'xr/openxr/foveation_with_subsampled_images': boolean;
   /** Specify the default reference space. */
   'xr/openxr/reference_space': int;
   /** If `true`, Godot will display an alert modal when OpenXR initialization fails on startup. */
@@ -3711,7 +3734,9 @@ declare interface ProjectSettings {
    */
   check_changed_settings_in_group(setting_prefix: string): boolean;
   /** Clears the whole configuration (not recommended, may break things). */
-  clear<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T): void;
+  clear<const T extends keyof ProjectSettings & `${string}/${string}`>(
+  name: T,
+  ): void;
   clear(name: string): void;
   /**
    * Gets an array of the settings which have been changed since the last save. Note that internally `changed_settings` is cleared after a successful save, so generally the most appropriate place to use this method is when processing {@link settings_changed}.
@@ -3728,26 +3753,43 @@ declare interface ProjectSettings {
    */
   get_global_class_list(): Array<Dictionary>;
   /** Returns the order of a configuration value (influences when saved to the config file). */
-  get_order<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T): int;
+  get_order<const T extends keyof ProjectSettings & `${string}/${string}`>(
+  name: T,
+  ): int;
   get_order(name: string): int;
   /**
    * Returns the value of the setting identified by `name`. If the setting doesn't exist and `default_value` is specified, the value of `default_value` is returned. Otherwise, `null` is returned.
    * **Note:** This method doesn't take potential feature overrides into account automatically. Use {@link get_setting_with_override} to handle seamlessly.
    * See also {@link has_setting} to check whether a setting exists.
    */
-  get_setting<const T extends keyof ProjectSettings & `${string}/${string}`, D>(name: T, default_value?: ProjectSettings[T]): ProjectSettings[T];
+  get_setting<const T extends keyof ProjectSettings & `${string}/${string}`, D>(
+  name: T,
+  default_value?: ProjectSettings[T],
+  ): ProjectSettings[T];
   get_setting(name: string, default_value?: unknown): unknown;
   /**
    * Similar to {@link get_setting}, but applies feature tag overrides if any exists and is valid.
    * **Example:** If the setting override `"application/config/name.windows"` exists, and the following code is executed on a *Windows* operating system, the overridden setting is printed instead:
    */
-  get_setting_with_override<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T): ProjectSettings[T];
+  get_setting_with_override<
+  const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+  name: T,
+  ): ProjectSettings[T];
   get_setting_with_override(name: string): unknown;
   /**
    * Similar to {@link get_setting_with_override}, but applies feature tag overrides instead of current OS features.
    */
-  get_setting_with_override_and_custom_features<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T, features: PackedStringArray): ProjectSettings[T];
-  get_setting_with_override_and_custom_features(name: string, features: PackedStringArray): unknown;
+  get_setting_with_override_and_custom_features<
+  const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+  name: T,
+  features: PackedStringArray,
+  ): ProjectSettings[T];
+  get_setting_with_override_and_custom_features(
+  name: string,
+  features: PackedStringArray,
+  ): unknown;
   /**
    * Returns the absolute, native OS path corresponding to the localized `path` (starting with `res://` or `user://`). The returned path will vary depending on the operating system and user preferences. See File paths in Godot projects ($DOCS_URL/tutorials/io/data_paths.html) to see what those paths convert to. See also {@link localize_path}.
    * **Note:** {@link globalize_path} with `res://` will not work in an exported project. Instead, prepend the executable's base directory to the path when running from an exported project:
@@ -3757,7 +3799,9 @@ declare interface ProjectSettings {
    * Returns `true` if a configuration value is present.
    * **Note:** In order to be be detected, custom settings have to be either defined with {@link set_setting}, or exist in the `project.godot` file. This is especially relevant when using {@link set_initial_value}.
    */
-  has_setting<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T): boolean;
+  has_setting<const T extends keyof ProjectSettings & `${string}/${string}`>(
+  name: T,
+  ): boolean;
   has_setting(name: string): boolean;
   /**
    * Loads the contents of the .pck or .zip file specified by `pack` into the resource filesystem (`res://`). Returns `true` on success.
@@ -3772,43 +3816,67 @@ declare interface ProjectSettings {
   localize_path(path: string | NodePath): string;
   /**
    * Saves the configuration to the `project.godot` file.
-   * **Note:** This method is intended to be used by editor plugins, as modified {@link ProjectSettings} can't be loaded back in the running app. If you want to change project settings in exported projects, use {@link save_custom} to save `override.cfg` file.
+   * **Note:** This method is intended to be used by editor plugins, as modified {@link ProjectSettings} can't be loaded back in the running app. If you want to change project settings in exported projects, use {@link save_custom} to save an `override.cfg` file.
    */
   save(): int;
   /**
-   * Saves the configuration to a custom file. The file extension must be `.godot` (to save in text-based {@link ConfigFile} format) or `.binary` (to save in binary format). You can also save `override.cfg` file, which is also text, but can be used in exported projects unlike other formats.
+   * Saves the configuration to a custom file. The file extension must be `.godot` (to save in text-based {@link ConfigFile} format) or `.binary` (to save in binary format). You can also save an `override.cfg` file, which is also text, but can be used in exported projects unlike other formats.
    */
   save_custom(file: string | NodePath): int;
   /**
    * Defines if the specified setting is considered basic or advanced. Basic settings will always be shown in the project settings. Advanced settings will only be shown if the user enables the "Advanced Settings" option.
    */
-  set_as_basic<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T, basic: boolean): void;
+  set_as_basic<const T extends keyof ProjectSettings & `${string}/${string}`>(
+  name: T,
+  basic: boolean,
+  ): void;
   set_as_basic(name: string, basic: boolean): void;
   /**
    * Defines if the specified setting is considered internal. An internal setting won't show up in the Project Settings dialog. This is mostly useful for addons that need to store their own internal settings without exposing them directly to the user.
    */
-  set_as_internal<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T, internal: boolean): void;
+  set_as_internal<
+  const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+  name: T,
+  internal: boolean,
+  ): void;
   set_as_internal(name: string, internal: boolean): void;
   /**
    * Sets the specified setting's initial value. This is the value the setting reverts to. The setting should already exist before calling this method. Note that project settings equal to their default value are not saved, so your code needs to account for that.
    * If you have a project setting defined by an {@link EditorPlugin}, but want to use it in a running project, you will need a similar code at runtime.
    */
-  set_initial_value<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T, value: unknown): void;
+  set_initial_value<
+  const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+  name: T,
+  value: unknown,
+  ): void;
   set_initial_value(name: string, value: unknown): void;
   /** Sets the order of a configuration value (influences when saved to the config file). */
-  set_order<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T, position: int): void;
+  set_order<const T extends keyof ProjectSettings & `${string}/${string}`>(
+  name: T,
+  position: int,
+  ): void;
   set_order(name: string, position: int): void;
   /**
    * Sets whether a setting requires restarting the editor to properly take effect.
    * **Note:** This is just a hint to display to the user that the editor must be restarted for changes to take effect. Enabling {@link set_restart_if_changed} does *not* delay the setting being set when changed.
    */
-  set_restart_if_changed<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T, restart: boolean): void;
+  set_restart_if_changed<
+  const T extends keyof ProjectSettings & `${string}/${string}`,
+  >(
+  name: T,
+  restart: boolean,
+  ): void;
   set_restart_if_changed(name: string, restart: boolean): void;
   /**
    * Sets the value of a setting.
    * This can also be used to erase custom project settings. To do this change the setting value to `null`.
    */
-  set_setting<const T extends keyof ProjectSettings & `${string}/${string}`>(name: T, value: unknown): void;
+  set_setting<const T extends keyof ProjectSettings & `${string}/${string}`>(
+  name: T,
+  value: unknown,
+  ): void;
   set_setting(name: string, value: unknown): void;
 
   /** Emitted when any setting is changed, up to once per process frame. */

package/typings/classes/Quaternion.d.ts

@@ -47,7 +47,7 @@ declare interface Quaternion {
   get_axis(): Vector3;
   /**
    * Returns this quaternion's rotation as a {@link Vector3} of Euler angles (https://en.wikipedia.org/wiki/Euler_angles), in radians.
-   * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). By default, the YXZ convention is used ({@link EULER_ORDER_YXZ}): Z (roll) is calculated first, then X (pitch), and lastly Y (yaw). When using the opposite method {@link from_euler}, this order is reversed.
+   * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). In Godot, Euler angles always use intrinsic order. By default, the intrinsic YXZ convention is used ({@link EULER_ORDER_YXZ}): since we are decomposing, local Z (roll) is calculated first, then local X (pitch), and lastly local Y (yaw). When using the opposite method {@link from_euler} to compose a rotation, this order is reversed.
    */
   get_euler(order?: int): Vector3;
   /**
@@ -174,7 +174,7 @@ declare interface QuaternionConstructor {
    */
   (x: float, y: float, z: float, w: float): Quaternion;
   /**
-   * Constructs a new {@link Quaternion} from the given {@link Vector3} of Euler angles (https://en.wikipedia.org/wiki/Euler_angles), in radians. This method always uses the YXZ convention ({@link EULER_ORDER_YXZ}).
+   * Constructs a new {@link Quaternion} from the given {@link Vector3} of Euler angles (https://en.wikipedia.org/wiki/Euler_angles), in radians. In Godot, Euler angles always use intrinsic order. This method always uses the intrinsic YXZ convention ({@link EULER_ORDER_YXZ}).
    */
   from_euler(euler: Vector3 | Vector3i): Quaternion;
 

package/typings/classes/RDAccelerationStructureGeometry.d.ts

@@ -0,0 +1,42 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Acceleration structure geometry (used by {@link RenderingDevice}). */
+declare class RDAccelerationStructureGeometry extends RefCounted {
+  /** Flags for the geometry. */
+  flags: int;
+  /** Buffer containing vertex indices. If `null`, triangles are non-indexed. */
+  index_buffer: RID;
+  /** Number of indices used by this geometry in {@link index_buffer}. */
+  index_count: int;
+  /** Byte offset of the first index in {@link index_buffer}. */
+  index_offset: int;
+  /** Buffer containing vertices. */
+  vertex_buffer: RID;
+  /** Number of vertices used by this geometry in {@link vertex_buffer}. */
+  vertex_count: int;
+  /** Format of the vertices in {@link vertex_buffer}. */
+  vertex_format: int;
+  /** Byte offset of the first vertex in {@link vertex_buffer}. */
+  vertex_offset: int;
+  /** Number of bytes between each vertex in {@link vertex_buffer}. */
+  vertex_stride: int;
+  set_flags(value: int): void;
+  get_flags(): int;
+  set_index_buffer(value: RID): void;
+  get_index_buffer(): RID;
+  set_index_count(value: int): void;
+  get_index_count(): int;
+  set_index_offset(value: int): void;
+  get_index_offset(): int;
+  set_vertex_buffer(value: RID): void;
+  get_vertex_buffer(): RID;
+  set_vertex_count(value: int): void;
+  get_vertex_count(): int;
+  set_vertex_format(value: int): void;
+  get_vertex_format(): int;
+  set_vertex_offset(value: int): void;
+  get_vertex_offset(): int;
+  set_vertex_stride(value: int): void;
+  get_vertex_stride(): int;
+}

package/typings/classes/RDAccelerationStructureInstance.d.ts

@@ -0,0 +1,34 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Acceleration structure instance (used by {@link RenderingDevice}). */
+declare class RDAccelerationStructureInstance extends RefCounted {
+  /**
+   * The BLAS referenced by this instance. If `null`, the instance is treated as a placeholder but still contributes to `gl_InstanceIndex` in GLSL.
+   */
+  blas: RID;
+  /** Flags for the instance. */
+  flags: int;
+  /**
+   * Hit shader binding table range used for this instance, allocated using the {@link RenderingDevice.hit_sbt_range_alloc} method.
+   */
+  hit_sbt_range: int;
+  /** Custom instance ID that can be accessed in GLSL using `gl_InstanceCustomIndexEXT`. */
+  id: int;
+  /** Visibility mask used to control which rays can intersect this instance. */
+  mask: int;
+  /** Transform applied to the referenced BLAS for this instance. */
+  transform: Transform3D;
+  set_blas(value: RID): void;
+  get_blas(): RID;
+  set_flags(value: int): void;
+  get_flags(): int;
+  set_hit_sbt_range(value: int): void;
+  get_hit_sbt_range(): int;
+  set_id(value: int): void;
+  get_id(): int;
+  set_mask(value: int): void;
+  get_mask(): int;
+  set_transform(value: Transform3D | Projection): void;
+  get_transform(): Transform3D;
+}

package/typings/classes/RDHitGroup.d.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Hit group (used by {@link RenderingDevice}). */
+declare class RDHitGroup extends RefCounted {
+  /** Any-hit shader for this hit group. Executed for each potential intersection. Can be `null`. */
+  any_hit_shader: RDPipelineShader | null;
+  /** Closest-hit shader for this hit group. Executed for the closest intersection. Can be `null`. */
+  closest_hit_shader: RDPipelineShader | null;
+  /**
+   * Intersection shader for this hit group. Required for non-triangle geometry. Must be `null` when using for triangle geometry.
+   */
+  intersection_shader: RDPipelineShader | null;
+  set_any_hit_shader(value: RDPipelineShader | null): void;
+  get_any_hit_shader(): RDPipelineShader | null;
+  set_closest_hit_shader(value: RDPipelineShader | null): void;
+  get_closest_hit_shader(): RDPipelineShader | null;
+  set_intersection_shader(value: RDPipelineShader | null): void;
+  get_intersection_shader(): RDPipelineShader | null;
+}

package/typings/classes/RDPipelineShader.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Pipeline shader (used by {@link RenderingDevice}). */
+declare class RDPipelineShader extends RefCounted {
+  /** Shader resource. The required stage is selected by the pipeline. */
+  shader: RID;
+  /** Specialization constants applied to the selected shader stage at pipeline creation time. */
+  specialization_constants: Array<RDPipelineSpecializationConstant>;
+  set_shader(value: RID): void;
+  get_shader(): RID;
+  set_specialization_constants(value: Array<RDPipelineSpecializationConstant>): void;
+  get_specialization_constants(): Array<RDPipelineSpecializationConstant>;
+}

package/typings/classes/RandomNumberGenerator.d.ts

@@ -6,8 +6,8 @@ declare class RandomNumberGenerator extends RefCounted {
   /**
    * Initializes the random number generator state based on the given seed value. A given seed will give a reproducible sequence of pseudo-random numbers.
    * **Note:** The RNG does not have an avalanche effect, and can output similar random streams given similar seeds. Consider using a hash function to improve your seed quality if they're sourced externally.
-   * **Note:** Setting this property produces a side effect of changing the internal {@link state}, so make sure to initialize the seed *before* modifying the {@link state}:
    * **Note:** The default value of this property is pseudo-random, and changes when calling {@link randomize}. The `0` value documented here is a placeholder, and not the actual default seed.
+   * **Note:** Setting this property produces a side effect of changing the internal {@link state}, so make sure to initialize the seed *before* modifying the {@link state}:
    */
   seed: int;
   /**
@@ -22,7 +22,9 @@ declare class RandomNumberGenerator extends RefCounted {
   get_state(): int;
 
   /**
-   * Returns a random index with non-uniform weights. Prints an error and returns `-1` if the array is empty.
+   * Returns a random integer between `0` and the size of the array that is passed as a parameter. Each value in the array should be a floating-point number that represents the relative likelihood that it will be returned as an index. A higher value means the value is more likely to be returned as an index, while a value of `0` means it will never be returned as an index.
+   * For example, if [code skip-lint][0.5, 1, 1, 2][/code] is passed as a parameter, then the method is twice as likely to return `3` (the index of the value `2`) and twice as unlikely to return `0` (the index of the value `0.5`) compared to the indices `1` and `2`.
+   * Prints an error and returns `-1` if the array is empty.
    */
   rand_weighted(weights: PackedFloat32Array | Array<unknown>): int;
   /** Returns a pseudo-random float between `0.0` and `1.0` (inclusive). */

package/typings/classes/RenderSceneBuffersConfiguration.d.ts

@@ -21,7 +21,10 @@ declare class RenderSceneBuffersConfiguration extends RefCounted {
   screen_space_aa: int;
   /** The target (upscale) size if scaling is used. */
   target_size: Vector2i;
-  /** Bias applied to mipmaps. */
+  /**
+   * Bias applied to mipmaps.
+   * **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;
   /** The number of views we're rendering. */
   view_count: int;