typescript-to-gdscript 0.1.1 → 0.1.3

package/typings/classes/Dictionary.d.ts

@@ -1,7 +1,31 @@
 // AUTO-GENERATED from Godot class documentation.
 // Manual overrides applied from typings-overrides/*.d.ts
 
-/** A built-in data structure that holds key-value pairs. */
+/**
+ * Override: Object (the structural base every value/dictionary inherits) —
+ * `this: T` generic methods so plain object literals and typed Dictionaries
+ * get key/value-aware typing for the Dictionary access methods.
+ *
+ * The `this: T` parameter (à la CallableFunction.apply/bind) infers the actual
+ * receiver type at the call site, so `keyof this` resolves to the real keys
+ * instead of collapsing to `keyof Object`. Each method pairs a typed overload
+ * (literal/known keys → precise type) with a permissive fallback (`unknown`
+ * key/value) so dynamic runtime keys, `{}` literals, and untyped Dictionaries
+ * keep compiling — matching GDScript's Variant semantics where these methods
+ * accept/return Variant. The typed overload comes first so it wins for known
+ * literal keys.
+ *
+ * Value/key TYPE ENFORCEMENT for typed dictionaries comes from the index
+ * signature on `Dictionary<K, V>` via the `[]` operator (`d[k] = v`), not from
+ * these methods — the permissive fallback intentionally allows `.set()` etc.
+ * with any value.
+ *
+ *   const d: Dictionary<string, int> = { x: 1 };
+ *   d.get("x");          // int      (typed overload)
+ *   d.get(someStr);      // unknown  (fallback)
+ *   d.keys();            // Array<string>
+ *   d["x"] = "no";       // ERROR    (index signature enforces value type)
+ */
 declare interface Object {
   /**
    * Assigns elements of another `dictionary` into the dictionary. Resizes the dictionary to match `dictionary`. Performs type conversions if the dictionary is typed.
@@ -14,7 +38,7 @@ declare interface Object {
    * By default, a **shallow** copy is returned: all nested {@link Array}, {@link Dictionary}, and {@link Resource} keys and values are shared with the original dictionary. Modifying any of those in one dictionary will also affect them in the other.
    * If `deep` is `true`, a **deep** copy is returned: all nested arrays and dictionaries are also duplicated (recursively). Any {@link Resource} is still shared with the original dictionary, though.
    */
-  duplicate(deep?: boolean): Dictionary;
+  duplicate<T>(this: T, deep?: boolean): T;
   /**
    * Duplicates this dictionary, deeply, like {@link duplicate} when passing `true`, with extra control over how subresources are handled.
    * `deep_subresources_mode` must be one of the values from {@link Resource.DeepDuplicateMode}. By default, only internal resources will be duplicated (recursively).
@@ -24,19 +48,24 @@ declare interface Object {
    * Removes the dictionary entry by key, if it exists. Returns `true` if the given `key` existed in the dictionary, otherwise `false`.
    * **Note:** Do not erase entries while iterating over the dictionary. You can iterate over the {@link keys} array instead.
    */
+  erase<T, K extends keyof T>(this: T, key: K): boolean;
   erase(key: unknown): boolean;
   /**
    * Finds and returns the first key whose associated value is equal to `value`, or `null` if it is not found.
    * **Note:** `null` is also a valid key. If inside the dictionary, {@link find_key} may give misleading results.
    */
+  find_key<T>(this: T, value: T[keyof T]): keyof T | null;
   find_key(value: unknown): unknown;
   /**
    * Returns the corresponding value for the given `key` in the dictionary. If the `key` does not exist, returns `default`, or `null` if the parameter is omitted.
+   * **Note:** If the `default` argument is computationally expensive or has unwanted side effects, consider using the {@link has} method instead:
    */
+  get<T, K extends keyof T>(this: T, key: K, default_?: T[K]): T[K];
   get(key: unknown, default_?: unknown): unknown;
   /**
    * Gets a value and ensures the key is set. If the `key` exists in the dictionary, this behaves like {@link get}. Otherwise, the `default` value is inserted into the dictionary and returned.
    */
+  get_or_add<T, K extends keyof T>(this: T, key: K, default_?: T[K]): T[K];
   get_or_add(key: unknown, default_?: unknown): unknown;
   /**
    * Returns the built-in {@link Variant} type of the typed dictionary's keys as a {@link Variant.Type} constant. If the keys are not typed, returns {@link TYPE_NIL}. See also {@link is_typed_key}.
@@ -67,6 +96,7 @@ declare interface Object {
    * In GDScript, this is equivalent to the `in` operator:
    * **Note:** This method returns `true` as long as the `key` exists, even if its corresponding value is `null`.
    */
+  has<T, K extends keyof T>(this: T, key: K): boolean;
   has(key: unknown): boolean;
   /** Returns `true` if the dictionary contains all keys in the given `keys` array. */
   has_all(keys: Array<unknown>): boolean;
@@ -97,7 +127,7 @@ declare interface Object {
   /** Returns `true` if the dictionary's values are typed. */
   is_typed_value(): boolean;
   /** Returns the list of keys in the dictionary. */
-  keys(): Array<unknown>;
+  keys<T>(this: T): Array<keyof T>;
   /**
    * Makes the dictionary read-only, i.e. disables modification of the dictionary's contents. Does not apply to nested content, e.g. content of nested dictionaries.
    */
@@ -111,7 +141,7 @@ declare interface Object {
    * Returns a copy of this dictionary merged with the other `dictionary`. By default, duplicate keys are not copied over, unless `overwrite` is `true`. See also {@link merge}.
    * This method is useful for quickly making dictionaries with default values:
    */
-  merged(dictionary: Dictionary, overwrite?: boolean): Dictionary;
+  merged<T>(this: T, dictionary: T, overwrite?: boolean): T;
   /**
    * Returns `true` if the two dictionaries contain the same keys and values, inner {@link Dictionary} and {@link Array} keys and values are compared recursively.
    */
@@ -119,6 +149,7 @@ declare interface Object {
   /**
    * Sets the value of the element at the given `key` to the given `value`. Returns `true` if the value is set successfully. Fails and returns `false` if the dictionary is read-only, or if `key` and `value` don't match the dictionary's types. This is the same as using the `[]` operator (`dict[key] = value`).
    */
+  set<T, K extends keyof T>(this: T, key: K, value: T[K]): boolean;
   set(key: unknown, value: unknown): boolean;
   /**
    * Returns the number of entries in the dictionary. Empty dictionaries (`{ }`) always return `0`. See also {@link is_empty}.
@@ -130,7 +161,7 @@ declare interface Object {
    */
   sort(): void;
   /** Returns the list of values in this dictionary. */
-  values(): Array<unknown>;
+  values<T>(this: T): Array<T[keyof T]>;
 
   // Operator overloads
   [__ops_ne]: { right: Dictionary; ret: boolean };
@@ -140,41 +171,56 @@ declare interface Object {
 }
 
 /**
- * Override: Dictionary<K, V> — typed key/value dictionary.
+ * Override: Dictionary typed surface.
  *
- * Extends the non-generic Object interface (which provides Dictionary methods
- * for {} literals) with generic overloads for typed dictionaries:
- *   var scores: Dictionary<string, int> = Dictionary();
- *   scores.set("player", 100);    // OK — key is string, value is int
- *   scores.get("player");         // returns int
- *   scores.keys();                // returns Array<string>
+ * `DictionaryTypedMethods<K, V>` is the single source of truth for the
+ * key/value-typed access methods. The generator derives `DictionaryKeyMethods`
+ * from it — `Omit<Object, keyof DictionaryTypedMethods> & DictionaryTypedMethods`
+ * — so the method-name list lives only here. Because the typed methods are
+ * all-`unknown` when K = V = unknown, a bare `Dictionary`
+ * (= DictionaryKeyMethods<unknown, unknown>) still accepts `{}` literals.
  */
-interface Dictionary<K = unknown, V = unknown> extends Object {
-  assign(dictionary: Dictionary<K, V>): void;
-  duplicate(deep?: boolean): Dictionary<K, V>;
-  duplicate_deep(deep_subresources_mode?: int): Dictionary<K, V>;
-  erase(key: K): boolean;
-  find_key(value: V): K | null;
+interface DictionaryTypedMethods<K = unknown, V = unknown> {
   get(key: K, default_?: V): V;
   get_or_add(key: K, default_?: V): V;
+  set(key: K, value: V): boolean;
   has(key: K): boolean;
   has_all(keys: Array<K>): boolean;
+  erase(key: K): boolean;
+  find_key(value: V): K | null;
   keys(): Array<K>;
+  values(): Array<V>;
+  assign(dictionary: Dictionary<K, V>): void;
   merge(dictionary: Dictionary<K, V>, overwrite?: boolean): void;
   merged(dictionary: Dictionary<K, V>, overwrite?: boolean): Dictionary<K, V>;
-  set(key: K, value: V): boolean;
-  values(): Array<V>;
+  duplicate(deep?: boolean): Dictionary<K, V>;
 }
+interface DictionaryKeyMethods<K = unknown, V = unknown>
+  extends Omit<Object, keyof DictionaryTypedMethods>,
+    DictionaryTypedMethods<K, V> {}
+type Dictionary<K = unknown, V = unknown> =
+  [K] extends [string | number]
+    ? { [P in K & (string | number)]: V }
+    : DictionaryKeyMethods<K, V>;
+/**
+ * Override: DictionaryConstructor — generic call signatures so
+ * `Dictionary<K, V>()` yields a typed dictionary. (Inference from a contextual
+ * type or a copy argument can't flow through the conditional `Dictionary` alias,
+ * so use explicit type arguments for a typed result.)
+ */
 declare interface DictionaryConstructor {
   readonly prototype: Dictionary;
-  /** Constructs an empty {@link Dictionary}. */
-  (): Dictionary;
-  /**
-   * Creates a typed dictionary from the `base` dictionary. A typed dictionary can only contain keys and values of the given types, or that inherit from the given classes, as described by this constructor's parameters.
-   */
-  (base: Dictionary, key_type: int, key_class_name: string, key_script: unknown, value_type: int, value_class_name: string, value_script: unknown): Dictionary;
-  /** Returns the same dictionary as `from`. If you need a copy of the dictionary, use {@link duplicate}. */
-  (from_: Dictionary): Dictionary;
+  <K = unknown, V = unknown>(): Dictionary<K, V>;
+  <K = unknown, V = unknown>(from_: Dictionary<K, V>): Dictionary<K, V>;
+  <K = unknown, V = unknown>(
+    base: Dictionary<K, V>,
+    key_type: int,
+    key_class_name: string,
+    key_script: unknown,
+    value_type: int,
+    value_class_name: string,
+    value_script: unknown,
+  ): Dictionary<K, V>;
 }
 declare const Dictionary: DictionaryConstructor;
 declare var Object: typeof GodotObject;

package/typings/classes/DirAccess.d.ts

@@ -92,12 +92,17 @@ declare class DirAccess extends RefCounted {
    * On other platforms, the method returns 0.
    */
   static get_drive_count(): int;
+  /**
+   * On Windows, returns the label of the drive (partition) passed as an argument.
+   * On other platforms, or if the requested drive does not exist, returns an empty String.
+   */
+  static get_drive_label(idx: int): string;
   /**
    * On Windows, returns the name of the drive (partition) passed as an argument (e.g. `C:`).
    * On macOS, returns the path to the mounted volume passed as an argument.
    * On Linux, returns the path to the mounted volume or GTK 3 bookmark passed as an argument.
    * On Android (API level 30+), returns the path to the mounted volume as an argument.
-   * On other platforms, or if the requested drive does not exist, the method returns an empty String.
+   * On other platforms, or if the requested drive does not exist, returns an empty String.
    */
   static get_drive_name(idx: int): string;
   /**

package/typings/classes/DisplayServer.d.ts

@@ -95,7 +95,7 @@ declare interface DisplayServer extends GodotObject {
   /** Sets element background color. */
   accessibility_update_set_background_color(id: RID, color: Color): void;
   /** Sets element bounding box, relative to the node position. */
-  accessibility_update_set_bounds(id: RID, p_rect: Rect2 | Rect2i): void;
+  accessibility_update_set_bounds(id: RID, rect: Rect2 | Rect2i): void;
   /** Sets element checked state. */
   accessibility_update_set_checked(id: RID, checekd: boolean): void;
   /** Sets element class name. */
@@ -271,7 +271,7 @@ declare interface DisplayServer extends GodotObject {
    * Displays OS native dialog for selecting files or directories in the file system.
    * Each filter string in the `filters` array should be formatted like this: `*.png,*.jpg,*.jpeg;Image Files;image/png,image/jpeg`. The description text of the filter is optional and can be omitted. It is recommended to set both file extension and MIME type. See also {@link FileDialog.filters}.
    * Callbacks have the following arguments: `status: bool, selected_paths: PackedStringArray, selected_filter_index: int`. **On Android,** the third callback argument (`selected_filter_index`) is always `0`.
-   * **Note:** This method is implemented if the display server has the {@link FEATURE_NATIVE_DIALOG_FILE} feature. Supported platforms include Linux (X11/Wayland), Windows, macOS, and Android (API level 29+).
+   * **Note:** This method is implemented if the display server has the {@link FEATURE_NATIVE_DIALOG_FILE} feature. Supported platforms include Linux (X11/Wayland), Windows, macOS, and Android.
    * **Note:** `current_directory` might be ignored.
    * **Note:** Embedded file dialogs and Windows file dialogs support only file extensions, while Android, Linux, and macOS file dialogs also support MIME types.
    * **Note:** On Android and Linux, `show_hidden` is ignored.
@@ -771,6 +771,11 @@ declare interface DisplayServer extends GodotObject {
    * **Note:** This method is implemented on Android, iOS, macOS, Windows, and Linux (X11/Wayland).
    */
   is_dark_mode_supported(): boolean;
+  /**
+   * Returns `true` if the application is in picture-in-picture mode.
+   * **Note:** This method is implemented on Android.
+   */
+  is_in_pip_mode(window_id?: int): boolean;
   /**
    * Returns `true` if touch events are available (Android or iOS), the capability is detected on the Web platform or if {@link ProjectSettings.input_devices/pointing/emulate_touch_from_mouse} is `true`.
    */
@@ -824,6 +829,21 @@ declare interface DisplayServer extends GodotObject {
   mouse_get_position(): Vector2i;
   /** Sets the current mouse mode. See also {@link mouse_get_mode}. */
   mouse_set_mode(mouse_mode: int): void;
+  /**
+   * Enters picture-in-picture mode.
+   * **Note:** This method is implemented on Android.
+   */
+  pip_mode_enter(window_id?: int): void;
+  /**
+   * Specifies the aspect ratio for picture-in-picture mode.
+   * **Note:** This method is implemented on Android.
+   */
+  pip_mode_set_aspect_ratio(numerator: int, denominator: int, window_id?: int): void;
+  /**
+   * Specifies whether picture-in-picture mode should be entered automatically when the application goes in the background.
+   * **Note:** This method is implemented on Android.
+   */
+  pip_mode_set_auto_enter_on_background(auto_enter_on_background: boolean, window_id?: int): void;
   /**
    * Perform window manager processing, including input flushing. See also {@link force_process_and_drop_events}, {@link Input.flush_buffered_events} and {@link Input.use_accumulated_input}.
    */
@@ -941,7 +961,7 @@ declare interface DisplayServer extends GodotObject {
    */
   set_hardware_keyboard_connection_change_callback(callable: Callable): void;
   /**
-   * Sets the window icon (usually displayed in the top-left corner) with an {@link Image}. To use icons in the operating system's native format, use {@link set_native_icon} instead.
+   * Sets the application icon and icons of all windows with an {@link Image}. To use icons in the operating system's native format, use {@link set_native_icon} instead.
    * **Note:** Requires support for {@link FEATURE_ICON}.
    */
   set_icon(image: Image): void;
@@ -1113,6 +1133,24 @@ declare interface DisplayServer extends GodotObject {
   window_get_current_screen(window_id?: int): int;
   /** Returns the current value of the given window's `flag`. */
   window_get_flag(flag: int, window_id?: int): boolean;
+  /**
+   * When {@link window_is_hdr_output_enabled} returns `true`, this returns the current maximum luminance in nits (cd/m²) for HDR output by the window specified by `window_id`. If the maximum luminance is being automatically adjusted based on the screen's capabilities, this method will return that value. Otherwise, it will return the value set by {@link window_set_hdr_output_max_luminance}. This maximum luminance value is used when calculating {@link window_get_output_max_linear_value}.
+   * **Note:** This maximum luminance may not match the physical behavior of the screen, but will always be proportionally correct relative to {@link window_get_hdr_output_current_reference_luminance}.
+   */
+  window_get_hdr_output_current_max_luminance(window_id?: int): float;
+  /**
+   * When {@link window_is_hdr_output_enabled} returns `true`, this returns the current reference white luminance in nits (cd/m²) for HDR output by the window specified by `window_id`. If the reference luminance is being automatically adjusted to match the operating system brightness, this will return that value. Otherwise, it will return the value set by {@link window_set_hdr_output_reference_luminance}. This reference luminance value is used when calculating {@link window_get_output_max_linear_value}.
+   * **Note:** This reference white luminance may not match the physical behavior of the screen, but will always be proportionally correct relative to {@link window_get_hdr_output_current_max_luminance}.
+   */
+  window_get_hdr_output_current_reference_luminance(window_id?: int): float;
+  /**
+   * Returns the maximum luminance in nits (cd/m²) set for HDR output by the window specified by `window_id`. Negative values indicate that the value is being automatically adjusted based on the screen's capabilities. See also {@link window_get_hdr_output_current_max_luminance}.
+   */
+  window_get_hdr_output_max_luminance(window_id?: int): float;
+  /**
+   * Returns the reference white luminance in nits (cd/m²) set for HDR output by the window specified by `window_id`. Negative values indicate that the value is being automatically adjusted to match the operating system brightness. See also {@link window_get_hdr_output_current_reference_luminance}.
+   */
+  window_get_hdr_output_reference_luminance(window_id?: int): float;
   /** Returns the window's maximum size (in pixels). See also {@link window_set_max_size}. */
   window_get_max_size(window_id?: int): Vector2i;
   /** Returns the window's minimum size (in pixels). See also {@link window_set_min_size}. */
@@ -1124,6 +1162,10 @@ declare interface DisplayServer extends GodotObject {
    * **Note:** This method is implemented on Android, Linux (X11/Wayland), macOS, and Windows.
    */
   window_get_native_handle(handle_type: int, window_id?: int): int;
+  /**
+   * Returns the maximum value for linear color components that can be displayed for the window specified by `window_id`, regardless of SDR or HDR output. Returns `1.0` if HDR is not enabled or not supported. When HDR output is enabled, this is calculated based on {@link window_get_hdr_output_current_reference_luminance} and {@link window_get_hdr_output_current_max_luminance}. The {@link Window.output_max_linear_value_changed} signal will be emitted whenever this value changes. This value is used by tonemapping and other {@link Environment} effects to ensure that bright colors are presented in the range that can be displayed by this window. Corresponds to {@link Window.get_output_max_linear_value}.
+   */
+  window_get_output_max_linear_value(window_id?: int): float;
   /**
    * Returns the bounding box of control, or menu item that was used to open the popup window, in the screen coordinate system.
    */
@@ -1155,6 +1197,18 @@ declare interface DisplayServer extends GodotObject {
   window_get_vsync_mode(window_id?: int): int;
   /** Returns `true` if the window specified by `window_id` is focused. */
   window_is_focused(window_id?: int): boolean;
+  /**
+   * Returns `true` if HDR output is currently enabled for the window specified by `window_id`. The returned value may change dynamically based on system settings, screen capabilities, and which screen the window is currently on.
+   */
+  window_is_hdr_output_enabled(window_id?: int): boolean;
+  /**
+   * Returns `true` if HDR output is requested for the window specified by `window_id`. Corresponds to {@link Window.hdr_output_requested}.
+   */
+  window_is_hdr_output_requested(window_id?: int): boolean;
+  /**
+   * Returns `true` if the window specified by `window_id` supports HDR output. This depends on the platform, screen capabilities, system settings, and the screen the window is currently on.
+   */
+  window_is_hdr_output_supported(window_id?: int): boolean;
   /** Returns `true` if the given window can be maximized (the maximize button is enabled). */
   window_is_maximize_allowed(window_id?: int): boolean;
   /**
@@ -1175,6 +1229,10 @@ declare interface DisplayServer extends GodotObject {
    * Makes the window specified by `window_id` request attention, which is materialized by the window title and taskbar entry blinking until the window is focused. This usually has no visible effect if the window is currently focused. The exact behavior varies depending on the operating system.
    */
   window_request_attention(window_id?: int): void;
+  /**
+   * If `enable` is `true`, HDR output is requested for the window specified by `window_id`. The window will automatically switch between HDR and SDR if it is moved between screens, screen capabilities change, or system settings are modified. This will internally force {@link Viewport.use_hdr_2d} to be enabled on the main {@link Viewport}. All other {@link SubViewport} of the {@link Window} must have their {@link Viewport.use_hdr_2d} property enabled to produce HDR output. Corresponds to {@link Window.hdr_output_requested}.
+   */
+  window_request_hdr_output(enable: boolean, window_id?: int): void;
   /**
    * Sets the background color of the root window.
    * **Note:** This method is implemented only on Android.
@@ -1200,6 +1258,21 @@ declare interface DisplayServer extends GodotObject {
   window_set_exclusive(window_id: int, exclusive: boolean): void;
   /** Enables or disables the given window's given `flag`. */
   window_set_flag(flag: int, enabled: boolean, window_id?: int): void;
+  /**
+   * Sets the maximum luminance in nits (cd/m²) for HDR output by the window specified by `window_id`. If `max_luminance` is negative, the window uses the screen's maximum luminance that is reported by the operating system. By default, this luminance is set to `-1.0` for every window. Typically this property should be left at this default value, but may optionally be exposed through in-game settings to allow the player to correct an inaccurate maximum luminance reported by the operating system. See also {@link window_get_hdr_output_current_max_luminance} and {@link window_get_hdr_output_max_luminance}.
+   * **Note:** This method is only implemented on macOS and Windows. Other platforms will always use the screen's maximum luminance that is reported by the operating system.
+   */
+  window_set_hdr_output_max_luminance(max_luminance: float, window_id?: int): void;
+  /**
+   * Sets the reference white luminance in nits (cd/m²) for HDR output by the window specified by `window_id`. If `reference_luminance` is negative, the window automatically adjusts to the brightness set by the operating system. By default, this luminance is set to `-1.0` for every window. Typically this property should be left at this default value, but may optionally be exposed as an "HDR Brightness" in-game setting to allow the player to adjust the brightness of their game, independently of their device settings. See also {@link window_get_hdr_output_current_reference_luminance} and {@link window_get_hdr_output_reference_luminance}.
+   * **Note:** This method is only implemented on Windows. Other platforms will always use the reference luminance that is reported by the operating system.
+   */
+  window_set_hdr_output_reference_luminance(reference_luminance: float, window_id?: int): void;
+  /**
+   * Sets the window icon (usually displayed in the top-left corner) for the window specified by `window_id`.
+   * **Note:** This method is implemented on Linux and Windows.
+   */
+  window_set_icon(icon: Image, window_id?: int): void;
   /**
    * Sets whether Input Method Editor (https://en.wikipedia.org/wiki/Input_method) should be enabled for the window specified by `window_id`. See also {@link window_set_ime_position}.
    */
@@ -1273,6 +1346,19 @@ declare interface DisplayServer extends GodotObject {
    * **Note:** It's recommended to change this value using {@link Window.size} instead.
    */
   window_set_size(size: Vector2i | Vector2, window_id?: int): void;
+  /**
+   * Sets the type and state of the progress bar on the taskbar/dock icon of the window specified by `window_id`. See {@link ProgressState} for possible values and how each mode behaves.
+   * **Note:** This method is implemented only on Windows and macOS.
+   * **Note:** On macOS, the progress bar is displayed only for the main window.
+   */
+  window_set_taskbar_progress_state(state: int, window_id?: int): void;
+  /**
+   * Creates a progress bar on the taskbar/dock icon of the window specified by `window_id` if it does not exist, sets the progress of the icon.
+   * `value` acts as a relative percentage value, ranges from `0.0` (lowest) to `1.0` (highest).
+   * **Note:** This method is implemented only on Windows and macOS.
+   * **Note:** On macOS, the progress bar is displayed only for the main window.
+   */
+  window_set_taskbar_progress_value(value: float, window_id?: int): void;
   /**
    * Sets the title of the given window to `title`.
    * **Note:** It's recommended to change this value using {@link Window.title} instead.
@@ -1312,6 +1398,13 @@ declare interface DisplayServer extends GodotObject {
    */
   window_start_resize(edge: int, window_id?: int): void;
 
+  /**
+   * Emitted when the device orientation changes. `orientation` is the new orientation.
+   * Returns `1` for portrait, `2` for landscape, and `0` if the orientation is undefined.
+   * **Note:** This method is implemented on Android and iOS.
+   */
+  orientation_changed: Signal<[int]>;
+
   // enum Feature
   /**
    * Display server supports global menu. This allows the application to display its menu items in the operating system's top bar. **macOS**
@@ -1321,7 +1414,7 @@ declare interface DisplayServer extends GodotObject {
    * Display server supports multiple windows that can be moved outside of the main window. **Windows, macOS, Linux (X11)**
    */
   readonly FEATURE_SUBWINDOWS: int;
-  /** Display server supports touchscreen input. **Windows, Linux (X11), Android, iOS, Web** */
+  /** Display server supports touchscreen input. **Windows, Linux (X11/Wayland), Android, iOS, Web** */
   readonly FEATURE_TOUCHSCREEN: int;
   /** Display server supports mouse input. **Windows, macOS, Linux (X11/Wayland), Android, Web** */
   readonly FEATURE_MOUSE: int;
@@ -1428,6 +1521,10 @@ declare interface DisplayServer extends GodotObject {
    * Display server supports interaction with screen reader or Braille display. **Linux (X11/Wayland), macOS, Windows**
    */
   readonly FEATURE_ACCESSIBILITY_SCREEN_READER: int;
+  /** Display server supports HDR output. **Linux (Wayland), macOS, iOS, visionOS, Windows** */
+  readonly FEATURE_HDR_OUTPUT: int;
+  /** Display server supports putting the application in picture-in-picture mode. **Android** */
+  readonly FEATURE_PIP_MODE: int;
   // enum AccessibilityRole
   /** Unknown or custom role. */
   readonly ROLE_UNKNOWN: int;
@@ -1523,6 +1620,13 @@ declare interface DisplayServer extends GodotObject {
   readonly ROLE_DIALOG: int;
   /** Tooltip element. */
   readonly ROLE_TOOLTIP: int;
+  /** Region/landmark element. Screen readers can navigate between regions using landmark navigation. */
+  readonly ROLE_REGION: int;
+  /**
+   * Unifor text run.
+   * Note: This role is used for internal text elements, and should not be assigned to nodes.
+   */
+  readonly ROLE_TEXT_RUN: int;
   // enum AccessibilityPopupType
   /** Popup menu. */
   readonly POPUP_MENU: int;
@@ -1803,16 +1907,41 @@ declare interface DisplayServer extends GodotObject {
    * **Note:** Regardless of the platform, enabling full screen will change the window size to match the monitor's size. Therefore, make sure your project supports multiple resolutions ($DOCS_URL/tutorials/rendering/multiple_resolutions.html) when enabling full screen mode.
    */
   readonly WINDOW_MODE_EXCLUSIVE_FULLSCREEN: int;
+  // enum ProgressState
+  /** Stops displaying progress and returns the button to its normal state. */
+  readonly PROGRESS_STATE_NOPROGRESS: int;
+  /**
+   * The progress indicator shows an indeterminate progress.
+   * On Windows, the progress indicator does not grow in size, but cycles repeatedly along the length of the taskbar button by default.
+   */
+  readonly PROGRESS_STATE_INDETERMINATE: int;
+  /** The progress indicator shows progress normally. */
+  readonly PROGRESS_STATE_NORMAL: int;
+  /**
+   * The progress indicator shows that an error has occurred.
+   * On Windows, the progress indicator turns red by default to show that an error has occurred in one of the windows that is broadcasting progress.
+   */
+  readonly PROGRESS_STATE_ERROR: int;
+  /**
+   * The progress indicator shows it was paused.
+   * On Windows, the progress indicator turns yellow by default to show that progress is currently stopped in one of the windows but can be resumed by the user.
+   */
+  readonly PROGRESS_STATE_PAUSED: int;
   // enum WindowFlags
   /**
    * The window can't be resized by dragging its resize grip. It's still possible to resize the window using {@link window_set_size}. This flag is ignored for full screen windows.
+   * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
    */
   readonly WINDOW_FLAG_RESIZE_DISABLED: int;
   /**
    * The window do not have native title bar and other decorations. This flag is ignored for full-screen windows.
+   * **Note:** This flag is implemented on Linux (X11/Wayland), macOS, and Windows.
    */
   readonly WINDOW_FLAG_BORDERLESS: int;
-  /** The window is floating on top of all other windows. This flag is ignored for full-screen windows. */
+  /**
+   * The window is floating on top of all other windows. This flag is ignored for full-screen windows.
+   * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+   */
   readonly WINDOW_FLAG_ALWAYS_ON_TOP: int;
   /**
    * The window background can be transparent.
@@ -1821,10 +1950,14 @@ declare interface DisplayServer extends GodotObject {
    * **Note:** Transparency support is implemented on Android, but can only be enabled via {@link ProjectSettings.display/window/per_pixel_transparency/allowed}. This flag has no effect on Android.
    */
   readonly WINDOW_FLAG_TRANSPARENT: int;
-  /** The window can't be focused. No-focus window will ignore all input, except mouse clicks. */
+  /**
+   * The window can't be focused. No-focus window will ignore all input, except mouse clicks.
+   * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+   */
   readonly WINDOW_FLAG_NO_FOCUS: int;
   /**
    * Window is part of menu or {@link OptionButton} dropdown. This flag can't be changed when the window is visible. An active popup window will exclusively receive all input, without stealing focus from its parent. Popup windows are automatically closed when uses click outside it, or when an application is switched. Popup window must have transient parent set (see {@link window_set_transient}).
+   * **Note:** This flag is implemented on Linux (X11/Wayland), macOS, and Windows.
    */
   readonly WINDOW_FLAG_POPUP: int;
   /**
@@ -1834,7 +1967,10 @@ declare interface DisplayServer extends GodotObject {
    * **Note:** This flag is implemented only on macOS.
    */
   readonly WINDOW_FLAG_EXTEND_TO_TITLE: int;
-  /** All mouse events are passed to the underlying window of the same application. */
+  /**
+   * All mouse events are passed to the underlying window of the same application.
+   * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+   */
   readonly WINDOW_FLAG_MOUSE_PASSTHROUGH: int;
   /**
    * Window style is overridden, forcing sharp corners.
@@ -1849,16 +1985,17 @@ declare interface DisplayServer extends GodotObject {
   readonly WINDOW_FLAG_EXCLUDE_FROM_CAPTURE: int;
   /**
    * Signals the window manager that this window is supposed to be an implementation-defined "popup" (usually a floating, borderless, untileable and immovable child window).
+   * **Note:** This flag is implemented on Linux (Wayland).
    */
   readonly WINDOW_FLAG_POPUP_WM_HINT: int;
   /**
    * Window minimize button is disabled.
-   * **Note:** This flag is implemented on macOS and Windows.
+   * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
    */
   readonly WINDOW_FLAG_MINIMIZE_DISABLED: int;
   /**
    * Window maximize button is disabled.
-   * **Note:** This flag is implemented on macOS and Windows.
+   * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
    */
   readonly WINDOW_FLAG_MAXIMIZE_DISABLED: int;
   /** Represents the size of the {@link WindowFlags} enum. */
@@ -1894,6 +2031,11 @@ declare interface DisplayServer extends GodotObject {
    * **Note:** This flag is implemented only on Linux (Wayland).
    */
   readonly WINDOW_EVENT_FORCE_CLOSE: int;
+  /**
+   * Sent when the output max linear value returned by {@link Window.get_output_max_linear_value} has changed.
+   * This occurs when HDR output is enabled or disabled and when any HDR output luminance values of the window have changed, such as when the player adjusts their screen brightness setting or moves the window to a different screen.
+   */
+  readonly WINDOW_EVENT_OUTPUT_MAX_LINEAR_VALUE_CHANGED: int;
   // enum WindowResizeEdge
   /** Top-left edge of a window. */
   readonly WINDOW_EDGE_TOP_LEFT: int;
@@ -1977,6 +2119,16 @@ declare interface DisplayServer extends GodotObject {
    * - Linux (Wayland): `EGLConfig` for the window.
    */
   readonly EGL_CONFIG: int;
+  /**
+   * The GLX `VisualID` for the window.
+   * **Note:** Only available on Linux when using X11.
+   */
+  readonly GLX_VISUALID: int;
+  /**
+   * The `GLXFBConfig` for the window.
+   * **Note:** Only available on Linux when using X11.
+   */
+  readonly GLX_FBCONFIG: int;
   // enum TTSUtteranceEvent
   /** Utterance has begun to be spoken. */
   readonly TTS_UTTERANCE_STARTED: int;

package/typings/classes/DrawableTexture2D.d.ts

@@ -0,0 +1,43 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D texture that supports drawing to itself via Blit calls. */
+declare class DrawableTexture2D extends Texture2D {
+  resource_local_to_scene: boolean;
+
+  /**
+   * Draws to given `rect` on this texture by copying from the given `source`. A `modulate` color can be passed in for the shader to use, but defaults to White. The `mipmap` value can specify a draw to a lower mipmap level. The `material` parameter can take a ShaderMaterial with a TextureBlit Shader for custom drawing behavior.
+   */
+  blit_rect(rect: Rect2i | Rect2, source: Texture2D, modulate?: Color, mipmap?: int, material?: Material): void;
+  /**
+   * Draws to the given `rect` on this texture, as well as on up to 3 DrawableTexture `extra_targets`. All `extra_targets` must be the same size and DrawableFormat as the original target, otherwise the Shader may fail. Expects up to 4 Texture `sources`, but will replace missing `sources` with default Black Textures.
+   */
+  blit_rect_multi(rect: Rect2i | Rect2, sources: Array<Texture2D>, extra_targets: Array<DrawableTexture2D>, modulate?: Color, mipmap?: int, material?: Material): void;
+  /** Re-calculates the mipmaps for this texture on demand. */
+  generate_mipmaps(): void;
+  /** Returns `true` if mipmaps are set to be used on this DrawableTexture. */
+  get_use_mipmaps(): boolean;
+  /** Sets the format of this DrawableTexture. */
+  set_format(format: int): void;
+  /** Sets if mipmaps should be used on this DrawableTexture. */
+  set_use_mipmaps(mipmaps: boolean): void;
+  /** Initializes the DrawableTexture to a White texture of the given `width`, `height`, and `format`. */
+  setup(width: int, height: int, format: int, color?: Color, use_mipmaps?: boolean): void;
+
+  // enum DrawableFormat
+  /** OpenGL texture format RGBA with four components, each with a bitdepth of 8. */
+  static readonly DRAWABLE_FORMAT_RGBA8: int;
+  /**
+   * OpenGL texture format RGBA with four components, each with a bitdepth of 8.
+   * When drawn to, an sRGB to linear color space conversion is performed.
+   */
+  static readonly DRAWABLE_FORMAT_RGBA8_SRGB: int;
+  /**
+   * OpenGL texture format GL_RGBA16F where there are four components, each a 16-bit "half-precision" floating-point value.
+   */
+  static readonly DRAWABLE_FORMAT_RGBAH: int;
+  /**
+   * OpenGL texture format GL_RGBA32F where there are four components, each a 32-bit floating-point value.
+   */
+  static readonly DRAWABLE_FORMAT_RGBAF: int;
+}

package/typings/classes/EditorCommandPalette.d.ts

@@ -3,8 +3,6 @@
 
 /** Godot editor's command palette. */
 declare class EditorCommandPalette extends ConfirmationDialog {
-  dialog_hide_on_ok: boolean;
-
   /**
    * Adds a custom command to EditorCommandPalette.
    * - `command_name`: {@link String} (Name of the **Command**. This is displayed to the user.)

package/typings/classes/EditorContextMenuPlugin.d.ts

@@ -56,4 +56,8 @@ declare class EditorContextMenuPlugin extends RefCounted {
    * The paths array is empty if there weren't any nodes under cursor. The option callback will receive a typed array of {@link CanvasItem} nodes.
    */
   static readonly CONTEXT_SLOT_2D_EDITOR: int;
+  /**
+   * Context menu of the inspectors right-click menu. {@link _popup_menu} will be called with an array of two items: The first will be the object's ID, the second will be the property name. An object can be retrieved from it's ID via {@link @GlobalScope.instance_from_id} after converting it to an int. The option callback will receive the EditorProperty directly.
+   */
+  static readonly CONTEXT_SLOT_INSPECTOR_PROPERTY: int;
 }