typescript-to-gdscript 0.1.1 → 0.1.3

package/typings/classes/Input.d.ts

@@ -11,6 +11,10 @@ declare interface Input extends GodotObject {
    * If `true`, sends touch input events when clicking or dragging the mouse. See also {@link ProjectSettings.input_devices/pointing/emulate_touch_from_mouse}.
    */
   emulate_touch_from_mouse: boolean;
+  /**
+   * If `true`, joypad input (including motion sensors) and LED light changes will be ignored and joypad vibration will be stopped when the application is not focused.
+   */
+  ignore_joypad_on_unfocused_application: boolean;
   /** Controls the mouse mode. */
   mouse_mode: int;
   /**
@@ -23,6 +27,8 @@ declare interface Input extends GodotObject {
   is_emulating_mouse_from_touch(): boolean;
   set_emulate_touch_from_mouse(value: boolean): void;
   is_emulating_touch_from_mouse(): boolean;
+  set_ignore_joypad_on_unfocused_application(value: boolean): void;
+  is_ignoring_joypad_on_unfocused_application(): boolean;
   set_mouse_mode(value: int): void;
   get_mouse_mode(): int;
   set_use_accumulated_input(value: boolean): void;
@@ -40,6 +46,12 @@ declare interface Input extends GodotObject {
    * Adds a new mapping entry (in SDL2 format) to the mapping database. Optionally update already connected devices.
    */
   add_joy_mapping(mapping: string | NodePath, update_existing?: boolean): void;
+  /**
+   * Clears the calibration information for the specified joypad's motion sensors, if it has any and if they were calibrated.
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad motion sensors and calibration in your games.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  clear_joy_motion_sensors_calibration(device: int): void;
   /**
    * Sends all input events which are in the current buffer to the game loop. These events may have been buffered as a result of accumulated input ({@link use_accumulated_input}) or agile input flushing ({@link ProjectSettings.input_devices/buffering/agile_event_flushing}).
    * The engine will already do this itself at key execution points (at least once per frame). However, this can be useful in advanced cases where you want precise control over the timing of event handling.
@@ -67,7 +79,10 @@ declare interface Input extends GodotObject {
    * This is a shorthand for writing `Input.get_action_strength("positive_action") - Input.get_action_strength("negative_action")`.
    */
   get_axis(negative_action: string, positive_action: string): float;
-  /** Returns an {@link Array} containing the device IDs of all currently connected joypads. */
+  /**
+   * Returns an {@link Array} containing the device IDs of all currently connected joypads.
+   * **Note:** The order of connected joypads can not be guaranteed to be the same after a project and/or the editor is restarted, because Godot doesn't save the order of joypad connections. Joypads are registered in the order they are discovered by Godot.
+   */
   get_connected_joypads(): Array<int>;
   /** Returns the currently assigned cursor shape. */
   get_current_cursor_shape(): int;
@@ -83,33 +98,86 @@ declare interface Input extends GodotObject {
    * **Note:** For Android, {@link ProjectSettings.input_devices/sensors/enable_gyroscope} must be enabled.
    */
   get_gyroscope(): Vector3;
+  /**
+   * Returns the acceleration, including the force of gravity, in m/s² of the joypad's accelerometer sensor, if the joypad has one and it's currently enabled. Otherwise, the method returns {@link Vector3.ZERO}. See also {@link get_joy_gravity} and {@link set_joy_motion_sensors_enabled}.
+   * For a joypad held in front of you, the returned axes are defined as follows:
+   * +X ... -X: left ... right;
+   * +Y ... -Y: bottom ... top;
+   * +Z ... -Z: farther ... closer.
+   * The gravity part value is measured as a vector with length of `9.8` away from the center of the Earth, which is a negative Y value.
+   * **Note:** This feature is only supported on Windows, Linux, and macOS. On iOS, joypad accelerometer sensor reading is not supported due to OS limitations.
+   */
+  get_joy_accelerometer(device: int): Vector3;
   /** Returns the current value of the joypad axis at index `axis`. */
   get_joy_axis(device: int, axis: int): float;
   /**
-   * Returns an SDL2-compatible device GUID on platforms that use gamepad remapping, e.g. `030000004c050000c405000000010000`. Returns an empty string if it cannot be found. Godot uses the SDL2 game controller database (https://github.com/gabomdq/SDL_GameControllerDB) to determine gamepad names and mappings based on this GUID.
+   * Returns the gravity in m/s² of the joypad's accelerometer sensor, if the joypad has one and it's currently enabled. Otherwise, the method returns {@link Vector3.ZERO}. See also {@link get_joy_accelerometer} and {@link set_joy_motion_sensors_enabled}.
+   * For a joypad held in front of you, the returned axes are defined as follows:
+   * +X ... -X: left ... right;
+   * +Y ... -Y: bottom ... top;
+   * +Z ... -Z: farther ... closer.
+   * The gravity part value is measured as a vector with length of `9.8` away from the center of the Earth, which is a negative Y value.
+   * **Note:** This feature is only supported on Windows, Linux, and macOS. On iOS, joypad accelerometer sensor reading is not supported due to OS limitations.
+   */
+  get_joy_gravity(device: int): Vector3;
+  /**
+   * Returns an SDL-compatible device GUID on platforms that use gamepad remapping, e.g. `030000004c050000c405000000010000`. Returns an empty string if it cannot be found. Godot uses SDL's internal mappings, supplemented by community-contributed mappings, to determine gamepad names and mappings based on this GUID.
    * On Windows, all XInput joypad GUIDs will be overridden by Godot to `__XINPUT_DEVICE__`, because their mappings are the same.
    */
   get_joy_guid(device: int): string;
+  /**
+   * Returns the rotation rate in rad/s around a joypad's X, Y, and Z axes of the gyroscope sensor, if the joypad has one and it's currently enabled. Otherwise, the method returns {@link Vector3.ZERO}. See also {@link set_joy_motion_sensors_enabled}.
+   * The rotation is positive in the counter-clockwise direction.
+   * For a joypad held in front of you, the returned axes are defined as follows:
+   * X: Angular speed around the X axis (pitch);
+   * Y: Angular speed around the Y axis (yaw);
+   * Z: Angular speed around the Z axis (roll).
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad gyroscope and gyroscope calibration in your games.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  get_joy_gyroscope(device: int): Vector3;
   /**
    * Returns a dictionary with extra platform-specific information about the device, e.g. the raw gamepad name from the OS or the Steam Input index.
-   * On Windows, Linux, and macOS, the dictionary contains the following fields:
+   * On Windows, Linux, macOS, and iOS, the dictionary contains the following fields:
    * `raw_name`: The name of the controller as it came from the OS, before getting renamed by the controller database.
    * `vendor_id`: The USB vendor ID of the device.
    * `product_id`: The USB product ID of the device.
-   * `steam_input_index`: The Steam Input gamepad index, if the device is not a Steam Input device this key won't be present.
-   * On Windows, the dictionary can have an additional field:
-   * `xinput_index`: The index of the controller in the XInput system. This key won't be present for devices not handled by XInput.
-   * **Note:** The returned dictionary is always empty on Android, iOS, visionOS, and Web.
+   * `serial_number`: The serial number of the device. This key won't be present if the serial number is unavailable.
+   * The dictionary can also include the following fields under selected platforms:
+   * `steam_input_index`: The Steam Input gamepad index (Windows, Linux, and macOS only). If the device is not a Steam Input device this key won't be present.
+   * `xinput_index`: The index of the controller in the XInput system (Windows only). This key won't be present for devices not handled by XInput.
+   * **Note:** The returned dictionary is always empty on Android and Web.
    */
   get_joy_info(device: int): Dictionary;
+  /**
+   * Returns the calibration information about the specified joypad's motion sensors in the form of a {@link Dictionary}, if it has any and if they have been calibrated, otherwise returns an empty {@link Dictionary}.
+   * The dictionary contains the following fields:
+   * `gyroscope_offset`: average offset in gyroscope values from {@link Vector2.ZERO} in rad/s.
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad motion sensors and calibration in your games.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  get_joy_motion_sensors_calibration(device: int): Dictionary;
+  /**
+   * Returns the joypad's motion sensor rate in Hz, if the joypad has motion sensors and they're currently enabled. See also {@link set_joy_motion_sensors_enabled}.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  get_joy_motion_sensors_rate(device: int): float;
   /**
    * Returns the name of the joypad at the specified device index, e.g. `PS4 Controller`. Godot uses the SDL2 game controller database (https://github.com/gabomdq/SDL_GameControllerDB) to determine gamepad names.
    */
   get_joy_name(device: int): string;
-  /** Returns the duration of the current vibration effect in seconds. */
+  /**
+   * Returns the duration of the current vibration effect in seconds.
+   * **Note:** This method returns the same value that was passed to {@link start_joy_vibration}, and this value does **not** change when the joypad's vibration runs out, it only gets reset after a call to {@link stop_joy_vibration}.
+   * If you want to check if a joypad is still vibrating, use {@link is_joy_vibrating} instead.
+   */
   get_joy_vibration_duration(device: int): float;
+  /** Returns the remaining duration of the current vibration effect in seconds. */
+  get_joy_vibration_remaining_duration(device: int): float;
   /**
    * Returns the strength of the joypad vibration: x is the strength of the weak motor, and y is the strength of the strong motor.
+   * **Note:** This method returns the same values that were passed to {@link start_joy_vibration}, and these values do **not** change when the joypad's vibration runs out, they only get reset after a call to {@link stop_joy_vibration}.
+   * If you want to check if a joypad is still vibrating, use {@link is_joy_vibrating} instead.
    */
   get_joy_vibration_strength(device: int): Vector2;
   /**
@@ -138,9 +206,20 @@ declare interface Input extends GodotObject {
   get_vector(negative_x: string, positive_x: string, negative_y: string, positive_y: string, deadzone?: float): Vector2;
   /**
    * Returns `true` if the joypad has an LED light that can change colors and/or brightness. See also {@link set_joy_light}.
-   * **Note:** This feature is only supported on Windows, Linux, and macOS.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
    */
   has_joy_light(device: int): boolean;
+  /**
+   * Returns `true` if the joypad has motion sensors (accelerometer and gyroscope).
+   * **Note:** On iOS, joypad accelerometer sensor reading is not supported due to OS limitations.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  has_joy_motion_sensors(device: int): boolean;
+  /**
+   * Returns `true` if the joypad supports vibration. See also {@link start_joy_vibration}.
+   * **Note:** For macOS, vibration is only supported in macOS 11 and later. When connected via USB, vibration is only supported for major brand controllers (except Xbox One and Xbox Series X/S controllers) due to macOS limitations.
+   */
+  has_joy_vibration(device: int): boolean;
   /**
    * Returns `true` when the user has *started* pressing the action event in the current frame or physics tick. It will only return `true` on the frame or tick that the user pressed down the button.
    * This is useful for code that needs to run only once when an action is pressed, instead of every frame while it's pressed.
@@ -182,28 +261,60 @@ declare interface Input extends GodotObject {
    * Returns `true` if any action, key, joypad button, or mouse button is being pressed. This will also return `true` if any action is simulated via code by calling {@link action_press}.
    */
   is_anything_pressed(): boolean;
-  /** Returns `true` if you are pressing the joypad button at index `button`. */
+  /**
+   * Returns `true` if you are pressing the joypad button at index `button`.
+   * **Note:** If you want to check if a joypad button was just pressed, use Godot's input action system with {@link is_action_just_pressed} or use the {@link Node._input} method like this instead:
+   */
   is_joy_button_pressed(device: int, button: int): boolean;
   /**
    * Returns `true` if the system knows the specified device. This means that it sets all button and axis indices. Unknown joypads are not expected to match these constants, but you can still retrieve events from them.
    */
   is_joy_known(device: int): boolean;
+  /**
+   * Returns `true` if the joypad's motion sensors have been calibrated.
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad motion sensors and calibration in your games.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  is_joy_motion_sensors_calibrated(device: int): boolean;
+  /**
+   * Returns `true` if the joypad's motion sensors are currently being calibrated.
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad motion sensors and calibration in your games.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  is_joy_motion_sensors_calibrating(device: int): boolean;
+  /**
+   * Returns `true` if the requested joypad has motion sensors (accelerometer and gyroscope) and they are currently enabled. See also {@link set_joy_motion_sensors_enabled} and {@link has_joy_motion_sensors}.
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad motion sensors and calibration in your games.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  is_joy_motion_sensors_enabled(device: int): boolean;
+  /**
+   * Returns `true` if the joypad is still vibrating after a call to {@link start_joy_vibration}.
+   * Unlike {@link get_joy_vibration_strength} and {@link get_joy_vibration_duration}, this method returns `false` after the joypad's vibration runs out.
+   */
+  is_joy_vibrating(device: int): boolean;
   /**
    * Returns `true` if you are pressing the key with the `keycode` printed on it. You can pass a {@link Key} constant or any Unicode character code.
+   * **Note:** If you want to check if a key was just pressed by using its label, use Godot's input action system with {@link is_action_just_pressed} or use the {@link Node._input} method like this instead:
    */
   is_key_label_pressed(keycode: int): boolean;
   /**
    * Returns `true` if you are pressing the Latin key in the current keyboard layout. You can pass a {@link Key} constant.
    * {@link is_key_pressed} is only recommended over {@link is_physical_key_pressed} in non-game applications. This ensures that shortcut keys behave as expected depending on the user's keyboard layout, as keyboard shortcuts are generally dependent on the keyboard layout in non-game applications. If in doubt, use {@link is_physical_key_pressed}.
    * **Note:** Due to keyboard ghosting, {@link is_key_pressed} may return `false` even if one of the action's keys is pressed. See Input examples ($DOCS_URL/tutorials/inputs/input_examples.html#keyboard-events) in the documentation for more information.
+   * **Note:** If you want to check if a key was just pressed by using its keycode, use Godot's input action system with {@link is_action_just_pressed} or use the {@link Node._input} method like this instead:
    */
   is_key_pressed(keycode: int): boolean;
-  /** Returns `true` if you are pressing the mouse button specified with {@link MouseButton}. */
+  /**
+   * Returns `true` if you are pressing the mouse button specified with {@link MouseButton}.
+   * **Note:** If you want to check if a mouse button was just pressed, use Godot's input action system with {@link is_action_just_pressed} or use the {@link Node._input} method like this instead:
+   */
   is_mouse_button_pressed(button: int): boolean;
   /**
    * Returns `true` if you are pressing the key in the physical location on the 101/102-key US QWERTY keyboard. You can pass a {@link Key} constant.
    * {@link is_physical_key_pressed} is recommended over {@link is_key_pressed} for in-game actions, as it will make `W`/`A`/`S`/`D` layouts work regardless of the user's keyboard layout. {@link is_physical_key_pressed} will also ensure that the top row number keys work on any keyboard layout. If in doubt, use {@link is_physical_key_pressed}.
    * **Note:** Due to keyboard ghosting, {@link is_physical_key_pressed} may return `false` even if one of the action's keys is pressed. See Input examples ($DOCS_URL/tutorials/inputs/input_examples.html#keyboard-events) in the documentation for more information.
+   * **Note:** If you want to check if a key was just pressed by using its physical keycode, use Godot's input action system with {@link is_action_just_pressed} or use the {@link Node._input} method like this instead:
    */
   is_physical_key_pressed(keycode: int): boolean;
   /**
@@ -249,9 +360,22 @@ declare interface Input extends GodotObject {
   /**
    * Sets the joypad's LED light, if available, to the specified color. See also {@link has_joy_light}.
    * **Note:** There is no way to get the color of the light from a joypad. If you need to know the assigned color, store it separately.
-   * **Note:** This feature is only supported on Windows, Linux, and macOS.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
    */
   set_joy_light(device: int, color: Color): void;
+  /**
+   * Sets the specified joypad's calibration information. See also {@link get_joy_motion_sensors_calibration}.
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad motion sensors and calibration in your games.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  set_joy_motion_sensors_calibration(device: int, calibration_info: Dictionary): void;
+  /**
+   * Enables or disables the motion sensors (accelerometer and gyroscope), if available, on the specified joypad.
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad motion sensors and calibration in your games.
+   * It's recommended to disable the motion sensors when they're no longer being used, because otherwise it might drain the controller battery faster.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  set_joy_motion_sensors_enabled(device: int, enable: boolean): void;
   /**
    * Sets the value of the magnetic field of the magnetometer sensor. Can be used for debugging on devices without a hardware sensor, for example in an editor on a PC.
    * **Note:** This value can be immediately overwritten by the hardware sensor value on Android and iOS.
@@ -263,11 +387,30 @@ declare interface Input extends GodotObject {
    */
   should_ignore_device(vendor_id: int, product_id: int): boolean;
   /**
-   * Starts to vibrate the joypad. Joypads usually come with two rumble motors, a strong and a weak one. `weak_magnitude` is the strength of the weak motor (between 0 and 1) and `strong_magnitude` is the strength of the strong motor (between 0 and 1). `duration` is the duration of the effect in seconds (a duration of 0 will try to play the vibration indefinitely). The vibration can be stopped early by calling {@link stop_joy_vibration}.
-   * **Note:** Not every hardware is compatible with long effect durations; it is recommended to restart an effect if it has to be played for more than a few seconds.
-   * **Note:** For macOS, vibration is only supported in macOS 11 and later.
+   * Starts the process of calibrating the specified joypad's gyroscope, if it has one.
+   * Once a joypad's gyroscope has been calibrated correctly (e.g. laying still on a table without being rotated), {@link get_joy_gyroscope} will return values close or equal to {@link Vector3.ZERO} when the joypad is not being rotated.
+   * Here's an example of how to use joypad gyroscope and gyroscope calibration in your games:
+   * **Note:** Accelerometer sensor doesn't usually require calibration.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  start_joy_motion_sensors_calibration(device: int): void;
+  /**
+   * Starts to vibrate the joypad. See also {@link has_joy_vibration} and {@link is_joy_vibrating}.
+   * Joypads usually come with two rumble motors, a strong and a weak one.
+   * `weak_magnitude` is the strength of the weak motor (between `0.0` and `1.0`).
+   * `strong_magnitude` is the strength of the strong motor (between `0.0` and `1.0`).
+   * `duration` is the duration of the effect in seconds (a duration of `0.0` will try to play the vibration as long as possible, which is about 65 seconds).
+   * The vibration can be stopped early by calling {@link stop_joy_vibration}.
+   * See also {@link get_joy_vibration_strength} and {@link get_joy_vibration_duration}.
+   * **Note:** For macOS, vibration is only supported in macOS 11 and later. When connected via USB, vibration is only supported for major brand controllers (except Xbox One and Xbox Series X/S controllers) due to macOS limitations.
    */
   start_joy_vibration(device: int, weak_magnitude: float, strong_magnitude: float, duration?: float): void;
+  /**
+   * Stops the calibration process of the specified joypad's motion sensors.
+   * See {@link start_joy_motion_sensors_calibration} for an example on how to use joypad motion sensors and calibration in your games.
+   * **Note:** This feature is only supported on Windows, Linux, macOS, and iOS.
+   */
+  stop_joy_motion_sensors_calibration(device: int): void;
   /** Stops the vibration of the joypad started with {@link start_joy_vibration}. */
   stop_joy_vibration(device: int): void;
   /**
@@ -278,6 +421,7 @@ declare interface Input extends GodotObject {
    * **Note:** For iOS, specifying the duration is only supported in iOS 13 and later.
    * **Note:** For Web, the amplitude cannot be changed.
    * **Note:** Some web browsers such as Safari and Firefox for Android do not support {@link vibrate_handheld}.
+   * **Note:** Device settings such as vibration on/off, "do not disturb" mode or specific haptic feedback on/off may prevent {@link vibrate_handheld} effects.
    */
   vibrate_handheld(duration_ms?: int, amplitude?: float): void;
   /**

package/typings/classes/InputEvent.d.ts

@@ -74,4 +74,12 @@ declare class InputEvent extends Resource {
    * Device ID used for emulated mouse input from a touchscreen, or for emulated touch input from a mouse. This can be used to distinguish emulated mouse input from physical mouse input, or emulated touch input from physical touch input.
    */
   static readonly DEVICE_ID_EMULATION: int;
+  /**
+   * Device ID used for input from a keyboard. This can be used to distinguish keyboard input events from joypad input events.
+   */
+  static readonly DEVICE_ID_KEYBOARD: int;
+  /**
+   * Device ID used for input from a mouse. This can be used to distinguish mouse input events from joypad input events.
+   */
+  static readonly DEVICE_ID_MOUSE: int;
 }

package/typings/classes/InputEventGesture.d.ts

@@ -4,9 +4,8 @@
 /** Abstract base class for touch gestures. */
 declare class InputEventGesture extends InputEventWithModifiers {
   /**
+   * <member name="position" type="Vector2" setter="set_position" getter="get_position" default="Vector2(0, 0)">
    * The local gesture position relative to the {@link Viewport}. If used in {@link Control._gui_input}, the position is relative to the current {@link Control} that received this gesture.
    */
-  position: Vector2;
-  set_position(value: Vector2 | Vector2i): void;
-  get_position(): Vector2;
+  device: int;
 }

package/typings/classes/InputEventMouse.d.ts

@@ -8,10 +8,11 @@ declare class InputEventMouse extends InputEventWithModifiers {
    */
   button_mask: int;
   /**
+   * <member name="global_position" type="Vector2" setter="set_global_position" getter="get_global_position" default="Vector2(0, 0)">
    * When received in {@link Node._input} or {@link Node._unhandled_input}, returns the mouse's position in the root {@link Viewport} using the coordinate system of the root {@link Viewport}.
    * When received in {@link Control._gui_input}, returns the mouse's position in the {@link CanvasLayer} that the {@link Control} is in using the coordinate system of the {@link CanvasLayer}.
    */
-  global_position: Vector2;
+  device: int;
   /**
    * When received in {@link Node._input} or {@link Node._unhandled_input}, returns the mouse's position in the {@link Viewport} this {@link Node} is in using the coordinate system of this {@link Viewport}.
    * When received in {@link Control._gui_input}, returns the mouse's position in the {@link Control} using the local coordinate system of the {@link Control}.
@@ -19,8 +20,6 @@ declare class InputEventMouse extends InputEventWithModifiers {
   position: Vector2;
   set_button_mask(value: int): void;
   get_button_mask(): int;
-  set_global_position(value: Vector2 | Vector2i): void;
-  get_global_position(): Vector2;
   set_position(value: Vector2 | Vector2i): void;
   get_position(): Vector2;
 }

package/typings/classes/InputEventMouseMotion.d.ts

@@ -24,7 +24,7 @@ declare class InputEventMouseMotion extends InputEventMouse {
   screen_relative: Vector2;
   /**
    * The unscaled mouse velocity in pixels per second in screen coordinates. This velocity is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformed_by}.
-   * **Note:** Use {@link screen_relative} for mouse aiming using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode.
+   * **Note:** In {@link Input.MOUSE_MODE_CAPTURED} mode, {@link screen_velocity} returns `(0, 0)` because the mouse cursor is hidden and locked. Use {@link screen_relative} for mouse aiming using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode.
    */
   screen_velocity: Vector2;
   /**
@@ -34,7 +34,7 @@ declare class InputEventMouseMotion extends InputEventMouse {
   /**
    * The mouse velocity in pixels per second.
    * **Note:** {@link velocity} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. That means mouse sensitivity may appear different depending on resolution.
-   * **Note:** Use {@link screen_relative} for mouse aiming using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode.
+   * **Note:** In {@link Input.MOUSE_MODE_CAPTURED} mode, {@link velocity} returns `(0, 0)` because the mouse cursor is hidden and locked. Use {@link screen_relative} for mouse aiming using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode.
    */
   velocity: Vector2;
   set_pen_inverted(value: boolean): void;

package/typings/classes/InputEventWithModifiers.d.ts

@@ -12,9 +12,10 @@ declare class InputEventWithModifiers extends InputEventFromWindow {
   /** State of the `Ctrl` modifier. */
   ctrl_pressed: boolean;
   /**
+   * <member name="meta_pressed" type="bool" setter="set_meta_pressed" getter="is_meta_pressed" default="false">
    * State of the `Meta` modifier. On Windows and Linux, this represents the Windows key (sometimes called "meta" or "super" on Linux). On macOS, this represents the Command key.
    */
-  meta_pressed: boolean;
+  device: int;
   /** State of the `Shift` modifier. */
   shift_pressed: boolean;
   set_alt_pressed(value: boolean): void;
@@ -23,8 +24,6 @@ declare class InputEventWithModifiers extends InputEventFromWindow {
   is_command_or_control_autoremap(): boolean;
   set_ctrl_pressed(value: boolean): void;
   is_ctrl_pressed(): boolean;
-  set_meta_pressed(value: boolean): void;
-  is_meta_pressed(): boolean;
   set_shift_pressed(value: boolean): void;
   is_shift_pressed(): boolean;
 

package/typings/classes/InputMap.d.ts

@@ -42,6 +42,9 @@ declare interface InputMap extends GodotObject {
    * Clears all {@link InputEventAction} in the {@link InputMap} and load it anew from {@link ProjectSettings}.
    */
   load_from_project_settings(): void;
+
+  /** Emitted when the {@link ProjectSettings} {@link InputMap} has been loaded. */
+  project_settings_loaded: Signal<[]>;
 }
 declare const InputMap: InputMap;
 

package/typings/classes/ItemList.d.ts

@@ -33,6 +33,26 @@ declare class ItemList extends Control {
   icon_scale: float;
   /** The number of items currently in the list. */
   item_count: int;
+  /**
+   * 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;
+  /**
+   * If `true`, the item at `index` is selectable.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/selectable': boolean;
+  /**
+   * The text of the item at `index`.
+   * **Note:** `index` is a value in the `0 .. item_count - 1` range.
+   */
+  'item_{index}/text': string;
   /**
    * Maximum columns the list will have.
    * If greater than zero, the content will be split among the specified columns.
@@ -107,13 +127,20 @@ declare class ItemList extends Control {
    * If `selectable` is `true`, the list item will be selectable.
    */
   add_item(text: string | NodePath, icon?: Texture2D, selectable?: boolean): int;
+  /**
+   * Ensures the currently selected item (the first selected item if multiple selection is enabled) is visible, adjusting the scroll position as necessary to place the item at the center of the list if possible. See also {@link ensure_current_is_visible}.
+   * Fails and prints an error if both arguments are `false`.
+   */
+  center_on_current(center_verically?: boolean, center_horizontally?: boolean): void;
   /** Removes all items from the list. */
   clear(): void;
   /** Ensures the item associated with the specified index is not selected. */
   deselect(idx: int): void;
   /** Ensures there are no items selected. */
   deselect_all(): void;
-  /** Ensure current selection is visible, adjusting the scroll position as necessary. */
+  /**
+   * Ensures the currently selected item (the first selected item if multiple selection is enabled) is visible, adjusting the scroll position as necessary. See also {@link center_on_current}.
+   */
   ensure_current_is_visible(): void;
   /**
    * Forces an update to the list size based on its items. This happens automatically whenever size of the items, or other relevant settings like {@link auto_height}, change. The method can be used to trigger the update ahead of next drawing pass.
@@ -181,7 +208,7 @@ declare class ItemList extends Control {
   /** Removes the item specified by `idx` index from the list. */
   remove_item(idx: int): void;
   /**
-   * Select the item at the specified index.
+   * Selects the item at the specified index.
    * **Note:** This method does not trigger the item selection signal.
    */
   select(idx: int, single?: boolean): void;

package/typings/classes/IterateIK3D.d.ts

@@ -43,7 +43,8 @@ declare class IterateIK3D extends ChainIK3D {
    * Returns the joint limitation rotation offset at `joint` in the bone chain's joint list.
    * Rotation is done in the local space which is constructed by the bone direction (in general parent to child) as the +Y axis and {@link get_joint_limitation_right_axis_vector} as the +X axis.
    * If the +X and +Y axes are not orthogonal, the +X axis is implicitly modified to make it orthogonal.
-   * Also, if the length of {@link get_joint_limitation_right_axis_vector} is zero, the space is created by rotating the bone rest using the shortest arc that rotates the +Y axis of the bone rest to match the bone direction.
+   * Also, if the length of {@link get_joint_limitation_right_axis_vector} is zero, the space is created by rotating the reference pose using the shortest arc that rotates the +Y axis of the reference pose to match the bone direction.
+   * In here, the reference pose is the bone pose immediately before processing IK.
    */
   get_joint_limitation_rotation_offset(index: int, joint: int): Quaternion;
   /** Returns the rotation axis at `joint` in the bone chain's joint list. */
@@ -65,12 +66,14 @@ declare class IterateIK3D extends ChainIK3D {
    * Sets the joint limitation rotation offset at `joint` in the bone chain's joint list.
    * Rotation is done in the local space which is constructed by the bone direction (in general parent to child) as the +Y axis and {@link get_joint_limitation_right_axis_vector} as the +X axis.
    * If the +X and +Y axes are not orthogonal, the +X axis is implicitly modified to make it orthogonal.
-   * Also, if the length of {@link get_joint_limitation_right_axis_vector} is zero, the space is created by rotating the bone rest using the shortest arc that rotates the +Y axis of the bone rest to match the bone direction.
+   * Also, if the length of {@link get_joint_limitation_right_axis_vector} is zero, the space is created by rotating the reference pose using the shortest arc that rotates the +Y axis of the reference pose to match the bone direction.
+   * In here, the reference pose is the bone pose immediately before processing IK.
    */
   set_joint_limitation_rotation_offset(index: int, joint: int, offset: Quaternion | Basis): void;
   /**
    * Sets the rotation axis at `joint` in the bone chain's joint list.
-   * The axes are based on the {@link Skeleton3D.get_bone_rest}'s space, if `axis` is {@link SkeletonModifier3D.ROTATION_AXIS_CUSTOM}, you can specify any axis.
+   * The axes are based on the reference pose's space, if `axis` is {@link SkeletonModifier3D.ROTATION_AXIS_CUSTOM}, you can specify any axis.
+   * In here, the reference pose is the bone pose immediately before processing IK.
    * **Note:** The rotation axis and the forward vector shouldn't be colinear to avoid unintended rotation since {@link ChainIK3D} does not factor in twisting forces.
    */
   set_joint_rotation_axis(index: int, joint: int, axis: int): void;

package/typings/classes/JavaClassWrapper.d.ts

@@ -3,6 +3,19 @@
 
 /** Provides access to the Java Native Interface. */
 declare interface JavaClassWrapper extends GodotObject {
+  /**
+   * Creates a {@link JavaObject} implementing the given Java interfaces using the given {@link Object} as the implementation.
+   * The `object` must contain methods signatures matching the methods signatures from the passed Java `interfaces`. Invoking methods from the Java `interfaces` will route to the matching `object` method.
+   * **Note:** This method only works on Android. On every other platform, this method will always return `null`.
+   */
+  create_proxy(object: GodotObject, interfaces: PackedStringArray | Array<unknown>): JavaObject | null;
+  /**
+   * Creates a {@link JavaObject} implementing the Java Single Abstract Method (SAM) interface using the Godot {@link Callable} as the implementation.
+   * The `sam_interface` **must be** a Java SAM interface, meaning it must only have a single abstract method to implement.
+   * The `callable` must be able to handle the same parameter types as the SAM interface method, and must provide the same return type. The `callable` will be invoked as a callback, passing the arguments from the Java SAM interface method.
+   * **Note:** This method only works on Android. On every other platform, this method will always return `null`.
+   */
+  create_sam_callback(sam_interface: string | NodePath, callable: Callable): JavaObject | null;
   /**
    * Returns the Java exception from the last call into a Java class. If there was no exception, it will return `null`.
    * **Note:** This method only works on Android. On every other platform, this method will always return `null`.

package/typings/classes/JavaScriptBridge.d.ts

@@ -34,7 +34,7 @@ declare interface JavaScriptBridge extends GodotObject {
    */
   get_interface(interface_: string | NodePath): JavaScriptObject | null;
   /**
-   * Returns `true` if the given `javascript_object` is of type `ArrayBuffer` (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), `DataView` (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView), or one of the many typed array objects (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray).
+   * Returns `true` if the given `javascript_object` is of type ArrayBuffer (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), DataView (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView), or one of the many typed array objects (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray).
    */
   is_js_buffer(javascript_object: JavaScriptObject): boolean;
   /**

package/typings/classes/Joint3D.d.ts

@@ -17,6 +17,7 @@ declare class Joint3D extends Node3D {
   node_b: NodePath;
   /**
    * The priority used to define which solver is executed first for multiple joints. The lower the value, the higher the priority.
+   * **Note:** Only supported when using GodotPhysics3D. This property is ignored when using Jolt Physics.
    */
   solver_priority: int;
   set_exclude_nodes_from_collision(value: boolean): void;

package/typings/classes/Label.d.ts

@@ -5,6 +5,7 @@
 declare class Label extends Control {
   /**
    * If set to something other than {@link TextServer.AUTOWRAP_OFF}, the text gets wrapped inside the node's bounding rectangle. If you resize the node, it will change its height automatically to show all the text.
+   * **Note:** Labels with autowrapping enabled must have a custom maximum width configured to work correctly, either through the Label's own {@link Control.custom_maximum_size} or as a result of a propagated maximum size from a parent Control with {@link Control.propagate_maximum_size} enabled.
    */
   autowrap_mode: int;
   /**

package/typings/classes/LabelSettings.d.ts

@@ -27,8 +27,33 @@ declare class LabelSettings extends Resource {
   shadow_size: int;
   /** The number of stacked outlines. */
   stacked_outline_count: int;
+  /**
+   * The color of the outline at `index`.
+   * **Note:** `index` is a value in the `0 .. stacked_outline_count - 1` range.
+   */
+  'stacked_outline_{index}/color': Color;
+  /**
+   * The size of the outline at `index`.
+   * **Note:** `index` is a value in the `0 .. stacked_outline_count - 1` range.
+   */
+  'stacked_outline_{index}/size': int;
   /** The number of stacked shadows. */
   stacked_shadow_count: int;
+  /**
+   * The color of the shadow at `index`.
+   * **Note:** `index` is a value in the `0 .. stacked_shadow_count - 1` range.
+   */
+  'stacked_shadow_{index}/color': Color;
+  /**
+   * The offset of the shadow at `index`.
+   * **Note:** `index` is a value in the `0 .. stacked_shadow_count - 1` range.
+   */
+  'stacked_shadow_{index}/offset': Vector2;
+  /**
+   * The size of the shadow outline at `index`.
+   * **Note:** `index` is a value in the `0 .. stacked_shadow_count - 1` range.
+   */
+  'stacked_shadow_{index}/outline_size': int;
   set_font(value: Font | null): void;
   get_font(): Font | null;
   set_font_color(value: Color): void;

package/typings/classes/Light3D.d.ts

@@ -76,7 +76,7 @@ declare class Light3D extends VisualInstance3D {
    */
   light_projector: Texture2D | null;
   /**
-   * The size of the light in Godot units. Only available for {@link OmniLight3D}s and {@link SpotLight3D}s. Increasing this value will make the light fade out slower and shadows appear blurrier (also called percentage-closer soft shadows, or PCSS). This can be used to simulate area lights to an extent. Increasing this value above `0.0` for lights with shadows enabled will have a noticeable performance cost due to PCSS.
+   * The simulated size of the light in Godot units, affecting shading and shadows. For {@link OmniLight3D}s and {@link SpotLight3D}s, increasing this value simulates a spherical area light, expanding the size of specular highlights. If shadows are enabled, a penumbra is rendered, making shadows appear blurrier. For {@link AreaLight3D}s, only the shadows are affected. Penumbras are simulated with percentage-closer soft shadows, or PCSS, which has a noticeable performance cost for values above `0.0`.
    * **Note:** {@link light_size} is not affected by {@link Node3D.scale} (the light's scale or its parent's scale).
    * **Note:** PCSS for positional lights is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
    */

package/typings/classes/Logger.d.ts

@@ -8,7 +8,7 @@ declare class Logger extends RefCounted {
    * The type of error provided by `error_type` is described in the {@link ErrorType} enumeration.
    * Additionally, `script_backtraces` provides backtraces for each of the script languages. These will only contain stack frames in editor builds and debug builds by default. To enable them for release builds as well, you need to enable {@link ProjectSettings.debug/settings/gdscript/always_track_call_stacks}.
    * **Warning:** This method will be called from threads other than the main thread, possibly at the same time, so you will need to have some kind of thread-safety in your implementation of it, like a {@link Mutex}.
-   * **Note:** `script_backtraces` will not contain any captured variables, due to its prohibitively high cost. To get those you will need to capture the backtraces yourself, from within the {@link Logger} virtual methods, using {@link Engine.capture_script_backtraces}.
+   * **Note:** `script_backtraces` will not contain any captured variables, due to its prohibitively high cost. To get those, you will need to capture the backtraces yourself, from within the {@link Logger} virtual methods, using {@link Engine.capture_script_backtraces}.
    * **Note:** Logging errors from this method using functions like {@link @GlobalScope.push_error} or {@link @GlobalScope.push_warning} is not supported, as it could cause infinite recursion. These errors will only show up in the console output.
    */
   _log_error(function_: string | NodePath, file: string | NodePath, line: int, code: string | NodePath, rationale: string | NodePath, editor_notify: boolean, error_type: int, script_backtraces: Array<ScriptBacktrace>): void;

package/typings/classes/LookAtModifier3D.d.ts

@@ -68,6 +68,7 @@ declare class LookAtModifier3D extends SkeletonModifier3D {
   primary_rotation_axis: int;
   /**
    * The relative option. If `true`, the rotation is applied relative to the pose. If `false`, the rotation is applied relative to the rest. It means to replace the current pose with the {@link LookAtModifier3D}'s result.
+   * **Note:** This option affects the base angle for {@link use_angle_limitation}. Since the {@link LookAtModifier3D} relies strongly on Euler rotation, the axis that determines the limitation and the actual rotation are strongly tied together.
    */
   relative: boolean;
   /** The threshold to start damping for {@link secondary_limit_angle}. */
@@ -99,7 +100,7 @@ declare class LookAtModifier3D extends SkeletonModifier3D {
   transition_type: int;
   /**
    * If `true`, limits the amount of rotation. For example, this helps to prevent a character's neck from rotating 360 degrees.
-   * **Note:** As with {@link AnimationTree} blending, interpolation is provided that favors {@link Skeleton3D.get_bone_rest}. This means that interpolation does not select the shortest path in some cases.
+   * **Note:** As with {@link AnimationTree} blending, interpolation is provided that favors {@link Skeleton3D.get_bone_rest} or {@link Skeleton3D.get_bone_pose} depends on the {@link relative} option. This means that interpolation does not select the shortest path in some cases.
    * **Note:** Some values for {@link transition_type} (such as {@link Tween.TRANS_BACK}, {@link Tween.TRANS_ELASTIC}, and {@link Tween.TRANS_SPRING}) may exceed the limitations. If interpolation occurs while overshooting the limitations, the result might not respect the bone rest.
    */
   use_angle_limitation: boolean;

package/typings/classes/MainLoop.d.ts

@@ -73,4 +73,8 @@ declare class MainLoop extends GodotObject {
   static readonly NOTIFICATION_APPLICATION_FOCUS_OUT: int;
   /** Notification received when text server is changed. */
   static readonly NOTIFICATION_TEXT_SERVER_CHANGED: int;
+  /** Notification received when the application enters picture-in-picture mode. */
+  static readonly NOTIFICATION_APPLICATION_PIP_MODE_ENTERED: int;
+  /** Notification received when the application exits picture-in-picture mode. */
+  static readonly NOTIFICATION_APPLICATION_PIP_MODE_EXITED: int;
 }