@ringozz/godot 0.1.0

package/gen/classes/DisplayServer.ts

@@ -0,0 +1,3119 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Error, HorizontalAlignment, Key, MouseButtonMask } from '../global-enums.ts';
+import type { Callable, GodotArray, GodotDictionary, PackedInt32Array, PackedStringArray, PackedVector2Array, RID, Signal, Variant } from '../heap-types/index.ts';
+import type { Color, Rect2, Rect2i, Transform2D, Vector2, Vector2i, Vector3i } from '../value-types/index.ts';
+import type { Image } from './Image.ts';
+import type { Resource } from './Resource.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 249));
+
+/**
+ * {@link DisplayServer} handles everything related to window management. It is separated from {@link OS} as a single operating system may support multiple display servers.
+ * **Headless mode:** Starting the engine with the `--headless` [command line argument]($DOCS_URL/tutorials/editor/command_line_tutorial.html) disables all rendering and window management functions. Most functions from {@link DisplayServer} will return dummy values in this case.
+ */
+export class DisplayServer extends GodotVar {
+
+    /**
+     * Returns `true` if the specified `feature` is supported by the current {@link DisplayServer}, `false` otherwise.
+     */
+    static hasFeature(feature: Feature): boolean { return _C($(), 7395, feature) as boolean; }
+
+    /**
+     * Returns the name of the {@link DisplayServer} currently in use. Most operating systems only have a single {@link DisplayServer}, but Linux has access to more than one {@link DisplayServer} (currently X11 and Wayland).
+     * The names of built-in display servers are `Windows`, `macOS`, `X11` (Linux), `Wayland` (Linux), `Android`, `iOS`, `web` (HTML5), and `headless` (when started with the `--headless` [command line argument]($DOCS_URL/tutorials/editor/command_line_tutorial.html)).
+     */
+    static getName(): string { return _C($(), 5602) as string; }
+
+    /**
+     * Sets native help system search callbacks.
+     * `searchCallback` has the following arguments: `String search_string, int result_limit` and return a {@link Dictionary} with "key, display name" pairs for the search results. Called when the user enters search terms in the `Help` menu.
+     * `actionCallback` has the following arguments: `String key`. Called when the user selects a search result in the `Help` menu.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static helpSetSearchCallbacks(searchCallback: Callable, actionCallback: Callable): void { _C($(), 7503, searchCallback, actionCallback); }
+
+    /**
+     * Registers callables to emit when the menu is respectively about to show or closed. Callback methods should have zero arguments.
+     */
+    static globalMenuSetPopupCallbacks(menuRoot: string, openCallback: Callable, closeCallback: Callable): void { _C($(), 7245, menuRoot, openCallback, closeCallback); }
+
+    /**
+     * Adds an item that will act as a submenu of the global menu `menuRoot`. The `submenu` argument is the ID of the global menu root that will be shown when the item is clicked.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddSubmenuItem(menuRoot: string, label: string, submenu: string, index?: number /* = -1 */): number { return _C($(), 7205, menuRoot, label, submenu, index) as number; }
+
+    /**
+     * Adds a new item with text `label` to the global menu with ID `menuRoot`.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * An `accelerator` can optionally be defined, which is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. The `accelerator` is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     * **Note:** The `callback` and `keyCallback` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to `tag`.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddItem(menuRoot: string, label: string, callback?: Callable /* = Callable() */, keyCallback?: Callable /* = Callable() */, tag?: Variant /* = null */, accelerator?: Key /* = 0 */, index?: number /* = -1 */): number { return _C($(), 7201, menuRoot, label, callback, keyCallback, tag, accelerator, index) as number; }
+
+    /**
+     * Adds a new checkable item with text `label` to the global menu with ID `menuRoot`.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * An `accelerator` can optionally be defined, which is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. The `accelerator` is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     * **Note:** The `callback` and `keyCallback` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to `tag`.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddCheckItem(menuRoot: string, label: string, callback?: Callable /* = Callable() */, keyCallback?: Callable /* = Callable() */, tag?: Variant /* = null */, accelerator?: Key /* = 0 */, index?: number /* = -1 */): number { return _C($(), 7197, menuRoot, label, callback, keyCallback, tag, accelerator, index) as number; }
+
+    /**
+     * Adds a new item with text `label` and icon `icon` to the global menu with ID `menuRoot`.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * An `accelerator` can optionally be defined, which is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. The `accelerator` is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     * **Note:** The `callback` and `keyCallback` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to `tag`.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddIconItem(menuRoot: string, icon: Texture2D, label: string, callback?: Callable /* = Callable() */, keyCallback?: Callable /* = Callable() */, tag?: Variant /* = null */, accelerator?: Key /* = 0 */, index?: number /* = -1 */): number { return _C($(), 7199, menuRoot, icon, label, callback, keyCallback, tag, accelerator, index) as number; }
+
+    /**
+     * Adds a new checkable item with text `label` and icon `icon` to the global menu with ID `menuRoot`.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * An `accelerator` can optionally be defined, which is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. The `accelerator` is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     * **Note:** The `callback` and `keyCallback` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to `tag`.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddIconCheckItem(menuRoot: string, icon: Texture2D, label: string, callback?: Callable /* = Callable() */, keyCallback?: Callable /* = Callable() */, tag?: Variant /* = null */, accelerator?: Key /* = 0 */, index?: number /* = -1 */): number { return _C($(), 7198, menuRoot, icon, label, callback, keyCallback, tag, accelerator, index) as number; }
+
+    /**
+     * Adds a new radio-checkable item with text `label` to the global menu with ID `menuRoot`.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * An `accelerator` can optionally be defined, which is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. The `accelerator` is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     * **Note:** Radio-checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See {@link globalMenuSetItemChecked} for more info on how to control it.
+     * **Note:** The `callback` and `keyCallback` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to `tag`.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddRadioCheckItem(menuRoot: string, label: string, callback?: Callable /* = Callable() */, keyCallback?: Callable /* = Callable() */, tag?: Variant /* = null */, accelerator?: Key /* = 0 */, index?: number /* = -1 */): number { return _C($(), 7203, menuRoot, label, callback, keyCallback, tag, accelerator, index) as number; }
+
+    /**
+     * Adds a new radio-checkable item with text `label` and icon `icon` to the global menu with ID `menuRoot`.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * An `accelerator` can optionally be defined, which is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. The `accelerator` is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     * **Note:** Radio-checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See {@link globalMenuSetItemChecked} for more info on how to control it.
+     * **Note:** The `callback` and `keyCallback` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to `tag`.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddIconRadioCheckItem(menuRoot: string, icon: Texture2D, label: string, callback?: Callable /* = Callable() */, keyCallback?: Callable /* = Callable() */, tag?: Variant /* = null */, accelerator?: Key /* = 0 */, index?: number /* = -1 */): number { return _C($(), 7200, menuRoot, icon, label, callback, keyCallback, tag, accelerator, index) as number; }
+
+    /**
+     * Adds a new item with text `label` to the global menu with ID `menuRoot`.
+     * Contrarily to normal binary items, multistate items can have more than two states, as defined by `maxStates`. Each press or activate of the item will increase the state by one. The default value is defined by `defaultState`.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * An `accelerator` can optionally be defined, which is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. The `accelerator` is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     * **Note:** By default, there's no indication of the current item state, it should be changed manually.
+     * **Note:** The `callback` and `keyCallback` Callables need to accept exactly one Variant parameter, the parameter passed to the Callables will be the value passed to `tag`.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddMultistateItem(menuRoot: string, label: string, maxStates: number, defaultState: number, callback?: Callable /* = Callable() */, keyCallback?: Callable /* = Callable() */, tag?: Variant /* = null */, accelerator?: Key /* = 0 */, index?: number /* = -1 */): number { return _C($(), 7202, menuRoot, label, maxStates, defaultState, callback, keyCallback, tag, accelerator, index) as number; }
+
+    /**
+     * Adds a separator between items to the global menu with ID `menuRoot`. Separators also occupy an index.
+     * Returns index of the inserted item, it's not guaranteed to be the same as `index` value.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuAddSeparator(menuRoot: string, index?: number /* = -1 */): number { return _C($(), 7204, menuRoot, index) as number; }
+
+    /**
+     * Returns the index of the item with the specified `text`. Indices are automatically assigned to each item by the engine, and cannot be set manually.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemIndexFromText(menuRoot: string, text: string): number { return _C($(), 7213, menuRoot, text) as number; }
+
+    /**
+     * Returns the index of the item with the specified `tag`. Indices are automatically assigned to each item by the engine, and cannot be set manually.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemIndexFromTag(menuRoot: string, tag: Variant): number { return _C($(), 7212, menuRoot, tag) as number; }
+
+    /**
+     * Returns `true` if the item at index `idx` is checked.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuIsItemChecked(menuRoot: string, idx: number): boolean { return _C($(), 7223, menuRoot, idx) as boolean; }
+
+    /**
+     * Returns `true` if the item at index `idx` is checkable in some way, i.e. if it has a checkbox or radio button.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuIsItemCheckable(menuRoot: string, idx: number): boolean { return _C($(), 7222, menuRoot, idx) as boolean; }
+
+    /**
+     * Returns `true` if the item at index `idx` has radio button-style checkability.
+     * **Note:** This is purely cosmetic; you must add the logic for checking/unchecking items in radio groups.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuIsItemRadioCheckable(menuRoot: string, idx: number): boolean { return _C($(), 7226, menuRoot, idx) as boolean; }
+
+    /**
+     * Returns the callback of the item at index `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemCallback(menuRoot: string, idx: number): Callable { return _C($(), 7208, menuRoot, idx) as Callable; }
+
+    /**
+     * Returns the callback of the item accelerator at index `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemKeyCallback(menuRoot: string, idx: number): Callable { return _C($(), 7214, menuRoot, idx) as Callable; }
+
+    /**
+     * Returns the metadata of the specified item, which might be of any type. You can set it with {@link globalMenuSetItemTag}, which provides a simple way of assigning context data to items.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemTag(menuRoot: string, idx: number): Variant { return _C($(), 7218, menuRoot, idx) as Variant; }
+
+    /**
+     * Returns the text of the item at index `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemText(menuRoot: string, idx: number): string { return _C($(), 7219, menuRoot, idx) as string; }
+
+    /**
+     * Returns the submenu ID of the item at index `idx`. See {@link globalMenuAddSubmenuItem} for more info on how to add a submenu.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemSubmenu(menuRoot: string, idx: number): string { return _C($(), 7217, menuRoot, idx) as string; }
+
+    /**
+     * Returns the accelerator of the item at index `idx`. Accelerators are special combinations of keys that activate the item, no matter which control is focused.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemAccelerator(menuRoot: string, idx: number): Key { return _C($(), 7207, menuRoot, idx) as Key; }
+
+    /**
+     * Returns `true` if the item at index `idx` is disabled. When it is disabled it can't be selected, or its action invoked.
+     * See {@link globalMenuSetItemDisabled} for more info on how to disable an item.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuIsItemDisabled(menuRoot: string, idx: number): boolean { return _C($(), 7224, menuRoot, idx) as boolean; }
+
+    /**
+     * Returns `true` if the item at index `idx` is hidden.
+     * See {@link globalMenuSetItemHidden} for more info on how to hide an item.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuIsItemHidden(menuRoot: string, idx: number): boolean { return _C($(), 7225, menuRoot, idx) as boolean; }
+
+    /**
+     * Returns the tooltip associated with the specified index `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemTooltip(menuRoot: string, idx: number): string { return _C($(), 7220, menuRoot, idx) as string; }
+
+    /**
+     * Returns the state of a multistate item. See {@link globalMenuAddMultistateItem} for details.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemState(menuRoot: string, idx: number): number { return _C($(), 7216, menuRoot, idx) as number; }
+
+    /**
+     * Returns number of states of a multistate item. See {@link globalMenuAddMultistateItem} for details.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemMaxStates(menuRoot: string, idx: number): number { return _C($(), 7215, menuRoot, idx) as number; }
+
+    /**
+     * Returns the icon of the item at index `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemIcon(menuRoot: string, idx: number): Texture2D { return _C($(), 7210, menuRoot, idx) as Texture2D; }
+
+    /**
+     * Returns the horizontal offset of the item at the given `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemIndentationLevel(menuRoot: string, idx: number): number { return _C($(), 7211, menuRoot, idx) as number; }
+
+    /**
+     * Sets the checkstate status of the item at index `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemChecked(menuRoot: string, idx: number, checked: boolean): void { _C($(), 7231, menuRoot, idx, checked); }
+
+    /**
+     * Sets whether the item at index `idx` has a checkbox. If `false`, sets the type of the item to plain text.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemCheckable(menuRoot: string, idx: number, checkable: boolean): void { _C($(), 7230, menuRoot, idx, checkable); }
+
+    /**
+     * Sets the type of the item at the specified index `idx` to radio button. If `false`, sets the type of the item to plain text.
+     * **Note:** This is purely cosmetic; you must add the logic for checking/unchecking items in radio groups.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemRadioCheckable(menuRoot: string, idx: number, checkable: boolean): void { _C($(), 7239, menuRoot, idx, checkable); }
+
+    /**
+     * Sets the callback of the item at index `idx`. Callback is emitted when an item is pressed.
+     * **Note:** The `callback` Callable needs to accept exactly one Variant parameter, the parameter passed to the Callable will be the value passed to the `tag` parameter when the menu item was created.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemCallback(menuRoot: string, idx: number, callback: Callable): void { _C($(), 7229, menuRoot, idx, callback); }
+
+    /**
+     * Sets the callback of the item at index `idx`. The callback is emitted when an item is hovered.
+     * **Note:** The `callback` Callable needs to accept exactly one Variant parameter, the parameter passed to the Callable will be the value passed to the `tag` parameter when the menu item was created.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemHoverCallbacks(menuRoot: string, idx: number, callback: Callable): void { _C($(), 7234, menuRoot, idx, callback); }
+
+    /**
+     * Sets the callback of the item at index `idx`. Callback is emitted when its accelerator is activated.
+     * **Note:** The `keyCallback` Callable needs to accept exactly one Variant parameter, the parameter passed to the Callable will be the value passed to the `tag` parameter when the menu item was created.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemKeyCallback(menuRoot: string, idx: number, keyCallback: Callable): void { _C($(), 7237, menuRoot, idx, keyCallback); }
+
+    /**
+     * Sets the metadata of an item, which may be of any type. You can later get it with {@link globalMenuGetItemTag}, which provides a simple way of assigning context data to items.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemTag(menuRoot: string, idx: number, tag: Variant): void { _C($(), 7242, menuRoot, idx, tag); }
+
+    /**
+     * Sets the text of the item at index `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemText(menuRoot: string, idx: number, text: string): void { _C($(), 7243, menuRoot, idx, text); }
+
+    /**
+     * Sets the submenu of the item at index `idx`. The submenu is the ID of a global menu root that would be shown when the item is clicked.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemSubmenu(menuRoot: string, idx: number, submenu: string): void { _C($(), 7241, menuRoot, idx, submenu); }
+
+    /**
+     * Sets the accelerator of the item at index `idx`. `keycode` can be a single {@link Key}, or a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemAccelerator(menuRoot: string, idx: number, keycode: Key): void { _C($(), 7228, menuRoot, idx, keycode); }
+
+    /**
+     * Enables/disables the item at index `idx`. When it is disabled, it can't be selected and its action can't be invoked.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemDisabled(menuRoot: string, idx: number, disabled: boolean): void { _C($(), 7232, menuRoot, idx, disabled); }
+
+    /**
+     * Hides/shows the item at index `idx`. When it is hidden, an item does not appear in a menu and its action cannot be invoked.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemHidden(menuRoot: string, idx: number, hidden: boolean): void { _C($(), 7233, menuRoot, idx, hidden); }
+
+    /**
+     * Sets the {@link String} tooltip of the item at the specified index `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemTooltip(menuRoot: string, idx: number, tooltip: string): void { _C($(), 7244, menuRoot, idx, tooltip); }
+
+    /**
+     * Sets the state of a multistate item. See {@link globalMenuAddMultistateItem} for details.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemState(menuRoot: string, idx: number, state: number): void { _C($(), 7240, menuRoot, idx, state); }
+
+    /**
+     * Sets number of state of a multistate item. See {@link globalMenuAddMultistateItem} for details.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemMaxStates(menuRoot: string, idx: number, maxStates: number): void { _C($(), 7238, menuRoot, idx, maxStates); }
+
+    /**
+     * Replaces the {@link Texture2D} icon of the specified `idx`.
+     * **Note:** This method is implemented only on macOS.
+     * **Note:** This method is not supported by macOS "_dock" menu items.
+     */
+    static globalMenuSetItemIcon(menuRoot: string, idx: number, icon: Texture2D): void { _C($(), 7235, menuRoot, idx, icon); }
+
+    /**
+     * Sets the horizontal offset of the item at the given `idx`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuSetItemIndentationLevel(menuRoot: string, idx: number, level: number): void { _C($(), 7236, menuRoot, idx, level); }
+
+    /**
+     * Returns number of items in the global menu with ID `menuRoot`.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetItemCount(menuRoot: string): number { return _C($(), 7209, menuRoot) as number; }
+
+    /**
+     * Removes the item at index `idx` from the global menu `menuRoot`.
+     * **Note:** The indices of items after the removed item will be shifted by one.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuRemoveItem(menuRoot: string, idx: number): void { _C($(), 7227, menuRoot, idx); }
+
+    /**
+     * Removes all items from the global menu with ID `menuRoot`.
+     * **Note:** This method is implemented only on macOS.
+     * **Supported system menu IDs:**
+     *
+     * ```text
+     *
+     * "_main" - Main menu (macOS).
+     * "_dock" - Dock popup menu (macOS).
+     * "_apple" - Apple menu (macOS, custom items added before "Services").
+     * "_window" - Window menu (macOS, custom items added after "Bring All to Front").
+     * "_help" - Help menu (macOS).
+     *
+     * ```
+     */
+    static globalMenuClear(menuRoot: string): void { _C($(), 7206, menuRoot); }
+
+    /**
+     * Returns Dictionary of supported system menu IDs and names.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static globalMenuGetSystemMenuRoots(): GodotDictionary { return _C($(), 7221) as GodotDictionary; }
+
+    /**
+     * Returns `true` if the synthesizer is generating speech, or have utterance waiting in the queue.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsIsSpeaking(): boolean { return _C($(), 14427) as boolean; }
+
+    /**
+     * Returns `true` if the synthesizer is in a paused state.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsIsPaused(): boolean { return _C($(), 14426) as boolean; }
+
+    /**
+     * Returns an {@link Array} of voice information dictionaries.
+     * Each {@link Dictionary} contains two {@link String} entries:
+     * - `name` is voice name.
+     * - `id` is voice identifier.
+     * - `language` is language code in `lang_Variant` format. The `lang` part is a 2 or 3-letter code based on the ISO-639 standard, in lowercase. The {@link code skip-lint}Variant part is an engine-dependent string describing country, region or/and dialect.
+     * Note that Godot depends on system libraries for text-to-speech functionality. These libraries are installed by default on Windows and macOS, but not on all Linux distributions. If they are not present, this method will return an empty list. This applies to both Godot users on Linux, as well as end-users on Linux running Godot games that use text-to-speech.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsGetVoices(): GodotArray<GodotDictionary> { return _C($(), 14424) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns a {@link PackedStringArray} of voice identifiers for the `language`.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsGetVoicesForLanguage(language: string): PackedStringArray { return _C($(), 14425, language) as PackedStringArray; }
+
+    /**
+     * Adds an utterance to the queue. If `interrupt` is `true`, the queue is cleared first.
+     * - `voice` identifier is one of the `"id"` values returned by {@link ttsGetVoices} or one of the values returned by {@link ttsGetVoicesForLanguage}.
+     * - `volume` ranges from `0` (lowest) to `100` (highest).
+     * - `pitch` ranges from `0.0` (lowest) to `2.0` (highest), `1.0` is default pitch for the current voice.
+     * - `rate` ranges from `0.1` (lowest) to `10.0` (highest), `1.0` is a normal speaking rate. Other values act as a percentage relative.
+     * - `utteranceId` is passed as a parameter to the callback functions.
+     * **Note:** On Windows and Linux (X11/Wayland), utterance `text` can use SSML markup. SSML support is engine and voice dependent. If the engine does not support SSML, you should strip out all XML markup before calling {@link ttsSpeak}.
+     * **Note:** The granularity of pitch, rate, and volume is engine and voice dependent. Values may be truncated.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsSpeak(text: string, voice: string, volume?: number /* = 50 */, pitch?: number /* = 1.0 */, rate?: number /* = 1.0 */, utteranceId?: number /* = 0,  int64 */, interrupt?: boolean /* = false */): void { _C($(), 14431, text, voice, volume, pitch, rate, utteranceId, interrupt); }
+
+    /**
+     * Puts the synthesizer into a paused state.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsPause(): void { _C($(), 14428); }
+
+    /**
+     * Resumes the synthesizer if it was paused.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsResume(): void { _C($(), 14429); }
+
+    /**
+     * Stops synthesis in progress and removes all utterances from the queue.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsStop(): void { _C($(), 14432); }
+
+    /**
+     * Adds a callback, which is called when the utterance has started, finished, canceled or reached a text boundary.
+     * - {@link TTS_UTTERANCE_STARTED}, {@link TTS_UTTERANCE_ENDED}, and {@link TTS_UTTERANCE_CANCELED} callable's method should take one {@link int} parameter, the utterance ID.
+     * - {@link TTS_UTTERANCE_BOUNDARY} callable's method should take two {@link int} parameters, the index of the character and the utterance ID.
+     * **Note:** The granularity of the boundary callbacks is engine dependent.
+     * **Note:** This method is implemented on Android, iOS, Web, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static ttsSetUtteranceCallback(event: TTSUtteranceEvent, callable: Callable): void { _C($(), 14430, event, callable); }
+
+    /**
+     * Returns `true` if OS supports dark mode.
+     * **Note:** This method is implemented on Android, iOS, macOS, Windows, and Linux (X11/Wayland).
+     */
+    static isDarkModeSupported(): boolean { return _C($(), 7869) as boolean; }
+
+    /**
+     * Returns `true` if OS is using dark mode.
+     * **Note:** This method is implemented on Android, iOS, macOS, Windows, and Linux (X11/Wayland).
+     */
+    static isDarkMode(): boolean { return _C($(), 7868) as boolean; }
+
+    /**
+     * Returns OS theme accent color. Returns `Color(0, 0, 0, 0)`, if accent color is unknown.
+     * **Note:** This method is implemented on macOS, Windows, Android, and Linux (X11/Wayland).
+     */
+    static getAccentColor(): Color { return _C($(), 3661) as Color; }
+
+    /**
+     * Returns the OS theme base color (default control background). Returns `Color(0, 0, 0, 0)` if the base color is unknown.
+     * **Note:** This method is implemented on macOS, Windows, and Android.
+     */
+    static getBaseColor(): Color { return _C($(), 3893) as Color; }
+
+    /**
+     * Sets the callback that should be called when the system's theme settings are changed. `callable` should accept zero arguments.
+     * **Note:** This method is implemented on Android, iOS, macOS, Windows, and Linux (X11/Wayland).
+     */
+    static setSystemThemeChangeCallback(callable: Callable): void { _C($(), 12967, callable); }
+
+    /**
+     * Sets the current mouse mode. See also {@link mouseGetMode}.
+     */
+    static mouseSetMode(mouseMode: MouseMode): void { _C($(), 8973, mouseMode); }
+
+    /**
+     * Returns the current mouse mode. See also {@link mouseSetMode}.
+     */
+    static mouseGetMode(): MouseMode { return _C($(), 8968) as MouseMode; }
+
+    /**
+     * Sets the mouse cursor position to the given `position` relative to an origin at the upper left corner of the currently focused game Window Manager window.
+     * **Note:** {@link warpMouse} is only supported on Windows, macOS, and Linux (X11/Wayland). It has no effect on Android, iOS, and Web.
+     */
+    static warpMouse(position: Vector2i): void { _C($(), 14840, position); }
+
+    /**
+     * Returns the mouse cursor's current position in screen coordinates.
+     */
+    static mouseGetPosition(): Vector2i { return _C($(), 8969) as Vector2i; }
+
+    /**
+     * Returns the current state of mouse buttons (whether each button is pressed) as a bitmask. If multiple mouse buttons are pressed at the same time, the bits are added together. Equivalent to {@link Input.getMouseButtonMask}.
+     */
+    static mouseGetButtonState(): MouseButtonMask { return _C($(), 8967) as MouseButtonMask; }
+
+    /**
+     * Sets the user's clipboard content to the given string.
+     */
+    static clipboardSet(clipboard: string): void { _C($(), 2329, clipboard); }
+
+    /**
+     * Returns the user's clipboard as a string if possible.
+     */
+    static clipboardGet(): string { return _C($(), 2324) as string; }
+
+    /**
+     * Returns the user's clipboard as an image if possible.
+     * **Note:** This method uses the copied pixel data, e.g. from an image editing software or a web browser, not an image file copied from file explorer.
+     */
+    static clipboardGetImage(): Image { return _C($(), 2325) as Image; }
+
+    /**
+     * Returns `true` if there is a text content on the user's clipboard.
+     */
+    static clipboardHas(): boolean { return _C($(), 2327) as boolean; }
+
+    /**
+     * Returns `true` if there is an image content on the user's clipboard.
+     */
+    static clipboardHasImage(): boolean { return _C($(), 2328) as boolean; }
+
+    /**
+     * Sets the user's [primary](https://unix.stackexchange.com/questions/139191/whats-the-difference-between-primary-selection-and-clipboard-buffer) clipboard content to the given string. This is the clipboard that is set when the user selects text in any application, rather than when pressing `Ctrl + C`. The clipboard data can then be pasted by clicking the middle mouse button in any application that supports the primary clipboard mechanism.
+     * **Note:** This method is only implemented on Linux (X11/Wayland).
+     */
+    static clipboardSetPrimary(clipboardPrimary: string): void { _C($(), 2330, clipboardPrimary); }
+
+    /**
+     * Returns the user's [primary](https://unix.stackexchange.com/questions/139191/whats-the-difference-between-primary-selection-and-clipboard-buffer) clipboard as a string if possible. This is the clipboard that is set when the user selects text in any application, rather than when pressing `Ctrl + C`. The clipboard data can then be pasted by clicking the middle mouse button in any application that supports the primary clipboard mechanism.
+     * **Note:** This method is only implemented on Linux (X11/Wayland).
+     */
+    static clipboardGetPrimary(): string { return _C($(), 2326) as string; }
+
+    /**
+     * Returns an {@link Array} of {@link Rect2}, each of which is the bounding rectangle for a display cutout or notch. These are non-functional areas on edge-to-edge screens used by cameras and sensors. Returns an empty array if the device does not have cutouts. See also {@link getDisplaySafeArea}.
+     * **Note:** Currently only implemented on Android. Other platforms will return an empty array even if they do have display cutouts or notches.
+     */
+    static getDisplayCutouts(): GodotArray<Rect2> { return _C($(), 4517) as GodotArray<Rect2>; }
+
+    /**
+     * Returns the unobscured area of the display where interactive controls should be rendered. See also {@link getDisplayCutouts}.
+     * **Note:** Currently only implemented on Android and iOS. On other platforms, `screen_get_usable_rect(SCREEN_OF_MAIN_WINDOW)` will be returned as a fallback. See also {@link screenGetUsableRect}.
+     */
+    static getDisplaySafeArea(): Rect2i { return _C($(), 4520) as Rect2i; }
+
+    /**
+     * Returns the number of displays available.
+     * **Note:** This method is implemented on Linux (X11 and Wayland), macOS, and Windows. On other platforms, this method always returns `1`.
+     */
+    static getScreenCount(): number { return _C($(), 6258) as number; }
+
+    /**
+     * Returns the index of the primary screen.
+     * **Note:** This method is implemented on Linux/X11, macOS, and Windows. On other platforms, this method always returns `0`.
+     */
+    static getPrimaryScreen(): number { return _C($(), 6012) as number; }
+
+    /**
+     * Returns the index of the screen containing the window with the keyboard focus, or the primary screen if there's no focused window.
+     * **Note:** This method is implemented on Linux/X11, macOS, and Windows. On other platforms, this method always returns the primary screen.
+     */
+    static getKeyboardFocusScreen(): number { return _C($(), 5291) as number; }
+
+    /**
+     * Returns the index of the screen that overlaps the most with the given rectangle. Returns {@link INVALID_SCREEN} if the rectangle doesn't overlap with any screen or has no area.
+     */
+    static getScreenFromRect(rect: Rect2): number { return _C($(), 6259, rect) as number; }
+
+    /**
+     * Returns the screen's top-left corner position in pixels. Returns {@link Vector2i.ZERO} if `screen` is invalid. On multi-monitor setups, the screen position is relative to the virtual desktop area. On multi-monitor setups with different screen resolutions or orientations, the origin might be located outside any display like this:
+     *
+     * ```text
+     *
+     * * (0, 0)        +-------+
+     *                 |       |
+     * +-------------+ |       |
+     * |             | |       |
+     * |             | |       |
+     * +-------------+ +-------+
+     *
+     * ```
+     *
+     * See also {@link screenGetSize}.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     */
+    static screenGetPosition(screen?: number /* = -1 */): Vector2i { return _C($(), 10256, screen) as Vector2i; }
+
+    /**
+     * Returns the screen's size in pixels. See also {@link screenGetPosition} and {@link screenGetUsableRect}. Returns {@link Vector2i.ZERO} if `screen` is invalid.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     */
+    static screenGetSize(screen?: number /* = -1 */): Vector2i { return _C($(), 10259, screen) as Vector2i; }
+
+    /**
+     * Returns the portion of the screen that is not obstructed by a status bar in pixels. See also {@link screenGetSize}.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     * **Note:** This method is implemented on Linux/X11, macOS, and Windows. On other platforms, this method always returns `Rect2i(screen_get_position(screen), screen_get_size(screen))`.
+     */
+    static screenGetUsableRect(screen?: number /* = -1 */): Rect2i { return _C($(), 10260, screen) as Rect2i; }
+
+    /**
+     * Returns the dots per inch density of the specified screen. Returns platform specific default value if `screen` is invalid.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     * **Note:** On macOS, returned value is inaccurate if fractional display scaling mode is used.
+     * **Note:** On Android devices, the actual screen densities are grouped into six generalized densities:
+     *
+     * ```text
+     *
+     *    ldpi - 120 dpi
+     *    mdpi - 160 dpi
+     *    hdpi - 240 dpi
+     *   xhdpi - 320 dpi
+     *  xxhdpi - 480 dpi
+     * xxxhdpi - 640 dpi
+     *
+     * ```
+     *
+     * **Note:** This method is implemented on Android, iOS, Linux (X11/Wayland), macOS, Web, and Windows. On other platforms, this method always returns `72`.
+     */
+    static screenGetDpi(screen?: number /* = -1 */): number { return _C($(), 10248, screen) as number; }
+
+    /**
+     * Returns the scale factor of the specified screen by index. Returns `1.0` if `screen` is invalid.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     * **Note:** On macOS, the returned value is `2.0` for hiDPI (Retina) screens, and `1.0` for all other cases.
+     * **Note:** On Linux (Wayland), the returned value is accurate only when `screen` is {@link SCREEN_OF_MAIN_WINDOW}. Due to API limitations, passing a direct index will return a rounded-up integer, if the screen has a fractional scale (e.g. `1.25` would get rounded up to `2.0`).
+     * **Note:** This method is implemented on Android, iOS, Web, macOS, and Linux (Wayland). On other platforms, this method always returns `1.0`.
+     */
+    static screenGetScale(screen?: number /* = -1 */): number { return _C($(), 10258, screen) as number; }
+
+    /**
+     * Returns `true` if touch events are available (Android or iOS), the capability is detected on the Web platform or if {@link ProjectSettings.inputDevices/pointing/emulateTouchFromMouse} is `true`.
+     */
+    static isTouchscreenAvailable(): boolean { return _C($(), 8369) as boolean; }
+
+    /**
+     * Returns the greatest scale factor of all screens.
+     * **Note:** On macOS returned value is `2.0` if there is at least one hiDPI (Retina) screen in the system, and `1.0` in all other cases.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static screenGetMaxScale(): number { return _C($(), 10253) as number; }
+
+    /**
+     * Returns the current refresh rate of the specified screen. When V-Sync is enabled, this returns the maximum framerate the project can effectively reach. Returns `-1.0` if `screen` is invalid or the {@link DisplayServer} fails to find the refresh rate for the specified screen.
+     * To fallback to a default refresh rate if the method fails, try:
+     *
+     * ```text
+     *
+     * var refresh_rate = DisplayServer.screen_get_refresh_rate()
+     * if refresh_rate < 0:
+     * 	refresh_rate = 60.0
+     *
+     * ```
+     *
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     * **Note:** This method is implemented on Android, iOS, macOS, Linux (X11 and Wayland), and Windows. On other platforms, this method always returns `-1.0`.
+     */
+    static screenGetRefreshRate(screen?: number /* = -1 */): number { return _C($(), 10257, screen) as number; }
+
+    /**
+     * Returns the color of the pixel at the given screen `position`. On multi-monitor setups, the screen position is relative to the virtual desktop area.
+     * **Note:** This method is implemented on Linux (X11, excluding XWayland), macOS, and Windows. On other platforms, this method always returns `Color(0, 0, 0, 1)`.
+     * **Note:** On macOS, this method requires the "Screen Recording" permission. If permission is not granted, this method returns a color from a screenshot that will not include other application windows or OS elements not related to the application.
+     */
+    static screenGetPixel(position: Vector2i): Color { return _C($(), 10255, position) as Color; }
+
+    /**
+     * Returns a screenshot of the `screen`. Returns `null` if `screen` is invalid or the {@link DisplayServer} fails to capture screenshot.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     * **Note:** This method is implemented on Linux (X11, excluding XWayland), macOS, and Windows. On other platforms, this method always returns `null`.
+     * **Note:** On macOS, this method requires the "Screen Recording" permission. If permission is not granted, this method returns a screenshot that will not include other application windows or OS elements not related to the application.
+     */
+    static screenGetImage(screen?: number /* = -1 */): Image | null { return _C($(), 10251, screen) as Image | null; }
+
+    /**
+     * Returns a screenshot of the screen region defined by `rect`. Returns `null` if `rect` is outside screen bounds or the {@link DisplayServer} fails to capture screenshot.
+     * **Note:** This method is implemented on macOS and Windows. On other platforms, this method always returns `null`.
+     * **Note:** On macOS, this method requires the "Screen Recording" permission. If permission is not granted, this method returns a screenshot that will not include other application windows or OS elements not related to the application.
+     */
+    static screenGetImageRect(rect: Rect2i): Image | null { return _C($(), 10252, rect) as Image | null; }
+
+    /**
+     * Sets the `screen`'s `orientation`. See also {@link screenGetOrientation}.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     * **Note:** This method is implemented on Android and iOS.
+     * **Note:** On iOS, this method has no effect if {@link ProjectSettings.display/window/handheld/orientation} is not set to {@link SCREEN_SENSOR}.
+     */
+    static screenSetOrientation(orientation: ScreenOrientation, screen?: number /* = -1 */): void { _C($(), 10266, orientation, screen); }
+
+    /**
+     * Returns the `screen`'s current orientation. See also {@link screenSetOrientation}. Returns {@link SCREEN_LANDSCAPE} if `screen` is invalid.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     * **Note:** This method is implemented on Android and iOS. On other platforms, this method always returns {@link SCREEN_LANDSCAPE}.
+     */
+    static screenGetOrientation(screen?: number /* = -1 */): ScreenOrientation { return _C($(), 10254, screen) as ScreenOrientation; }
+
+    /**
+     * Sets whether the screen should never be turned off by the operating system's power-saving measures. See also {@link screenIsKeptOn}.
+     */
+    static screenSetKeepOn(enable: boolean): void { _C($(), 10265, enable); }
+
+    /**
+     * Returns `true` if the screen should never be turned off by the operating system's power-saving measures. See also {@link screenSetKeepOn}.
+     */
+    static screenIsKeptOn(): boolean { return _C($(), 10262) as boolean; }
+
+    /**
+     * Returns the list of Godot window IDs belonging to this process.
+     * **Note:** Native dialogs are not included in this list.
+     */
+    static getWindowList(): PackedInt32Array { return _C($(), 7155) as PackedInt32Array; }
+
+    /**
+     * Returns the ID of the window at the specified screen `position` (in pixels). On multi-monitor setups, the screen position is relative to the virtual desktop area. On multi-monitor setups with different screen resolutions or orientations, the origin may be located outside any display like this:
+     *
+     * ```text
+     *
+     * * (0, 0)        +-------+
+     *                 |       |
+     * +-------------+ |       |
+     * |             | |       |
+     * |             | |       |
+     * +-------------+ +-------+
+     *
+     * ```
+     */
+    static getWindowAtScreenPosition(position: Vector2i): number { return _C($(), 7153, position) as number; }
+
+    /**
+     * Returns internal structure pointers for use in plugins.
+     * **Note:** This method is implemented on Android, Linux (X11/Wayland), macOS, and Windows.
+     */
+    static windowGetNativeHandle(handleType: HandleType, windowId?: number /* = 0 */): number { return _C($(), 14868, handleType, windowId) as number; }
+
+    /**
+     * Returns ID of the active popup window, or {@link INVALID_WINDOW_ID} if there is none.
+     */
+    static windowGetActivePopup(): number { return _C($(), 14857) as number; }
+
+    /**
+     * Sets the bounding box of control, or menu item that was used to open the popup window, in the screen coordinate system. Clicking this area will not auto-close this popup.
+     */
+    static windowSetPopupSafeRect(window: number, rect: Rect2i): void { _C($(), 14906, window, rect); }
+
+    /**
+     * Returns the bounding box of control, or menu item that was used to open the popup window, in the screen coordinate system.
+     */
+    static windowGetPopupSafeRect(window: number): Rect2i { return _C($(), 14870, window) as Rect2i; }
+
+    /**
+     * Sets the title of the given window to `title`.
+     * **Note:** It's recommended to change this value using {@link Window.title} instead.
+     * **Note:** Avoid changing the window title every frame, as this can cause performance issues on certain window managers. Try to change the window title only a few times per second at most.
+     */
+    static windowSetTitle(title: string, windowId?: number /* = 0 */): void { _C($(), 14912, title, windowId); }
+
+    /**
+     * Returns the estimated window title bar size (including text and window buttons) for the window specified by `windowId` (in pixels). This method does not change the window title.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static windowGetTitleSize(title: string, windowId?: number /* = 0 */): Vector2i { return _C($(), 14876, title, windowId) as Vector2i; }
+
+    /**
+     * Sets a polygonal region of the window which accepts mouse events. Mouse events outside the region will be passed through.
+     * Passing an empty array will disable passthrough support (all mouse events will be intercepted by the window, which is the default behavior).
+     *
+     *
+     * ```gdscript
+     *
+     * # Set region, using Path2D node.
+     * DisplayServer.window_set_mouse_passthrough($Path2D.curve.get_baked_points())
+     *
+     * # Set region, using Polygon2D node.
+     * DisplayServer.window_set_mouse_passthrough($Polygon2D.polygon)
+     *
+     * # Reset region to default.
+     * DisplayServer.window_set_mouse_passthrough([])
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** On Windows, the portion of a window that lies outside the region is not drawn, while on Linux (X11) and macOS it is.
+     * **Note:** This method is implemented on Linux (X11), macOS and Windows.
+     */
+    static windowSetMousePassthrough(region: PackedVector2Array, windowId?: number /* = 0 */): void { _C($(), 14905, region, windowId); }
+
+    /**
+     * Returns the screen the window specified by `windowId` is currently positioned on. If the screen overlaps multiple displays, the screen where the window's center is located is returned. See also {@link windowSetCurrentScreen}. Returns {@link INVALID_SCREEN} if `windowId` is invalid.
+     * **Note:** This method is implemented on Linux/X11, macOS, and Windows. On other platforms, this method always returns `0`.
+     */
+    static windowGetCurrentScreen(windowId?: number /* = 0 */): number { return _C($(), 14859, windowId) as number; }
+
+    /**
+     * Moves the window specified by `windowId` to the specified `screen`. See also {@link windowGetCurrentScreen}.
+     * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
+     * **Note:** This method is implemented on Linux/X11, macOS, and Windows.
+     */
+    static windowSetCurrentScreen(screen: number, windowId?: number /* = 0 */): void { _C($(), 14891, screen, windowId); }
+
+    /**
+     * Returns the position of the client area of the given window on the screen.
+     */
+    static windowGetPosition(windowId?: number /* = 0 */): Vector2i { return _C($(), 14871, windowId) as Vector2i; }
+
+    /**
+     * Returns the position of the given window on the screen including the borders drawn by the operating system. See also {@link windowGetPosition}.
+     */
+    static windowGetPositionWithDecorations(windowId?: number /* = 0 */): Vector2i { return _C($(), 14872, windowId) as Vector2i; }
+
+    /**
+     * Sets the position of the given window to `position`. On multi-monitor setups, the screen position is relative to the virtual desktop area. On multi-monitor setups with different screen resolutions or orientations, the origin may be located outside any display like this:
+     *
+     * ```text
+     *
+     * * (0, 0)        +-------+
+     *                 |       |
+     * +-------------+ |       |
+     * |             | |       |
+     * |             | |       |
+     * +-------------+ +-------+
+     *
+     * ```
+     *
+     * See also {@link windowGetPosition} and {@link windowSetSize}.
+     * **Note:** It's recommended to change this value using {@link Window.position} instead.
+     * **Note:** On Linux (Wayland): this method is a no-op.
+     */
+    static windowSetPosition(position: Vector2i, windowId?: number /* = 0 */): void { _C($(), 14907, position, windowId); }
+
+    /**
+     * Returns the size of the window specified by `windowId` (in pixels), excluding the borders drawn by the operating system. This is also called the "client area". See also {@link windowGetSizeWithDecorations}, {@link windowSetSize} and {@link windowGetPosition}.
+     */
+    static windowGetSize(windowId?: number /* = 0 */): Vector2i { return _C($(), 14874, windowId) as Vector2i; }
+
+    /**
+     * Sets the size of the given window to `size` (in pixels). See also {@link windowGetSize} and {@link windowGetPosition}.
+     * **Note:** It's recommended to change this value using {@link Window.size} instead.
+     */
+    static windowSetSize(size: Vector2i, windowId?: number /* = 0 */): void { _C($(), 14909, size, windowId); }
+
+    /**
+     * Sets the `callback` that will be called when the window specified by `windowId` is moved or resized.
+     * **Warning:** Advanced users only! Adding such a callback to a {@link Window} node will override its default implementation, which can introduce bugs.
+     */
+    static windowSetRectChangedCallback(callback: Callable, windowId?: number /* = 0 */): void { _C($(), 14908, callback, windowId); }
+
+    /**
+     * Sets the `callback` that will be called when an event occurs in the window specified by `windowId`.
+     * **Warning:** Advanced users only! Adding such a callback to a {@link Window} node will override its default implementation, which can introduce bugs.
+     */
+    static windowSetWindowEventCallback(callback: Callable, windowId?: number /* = 0 */): void { _C($(), 14916, callback, windowId); }
+
+    /**
+     * Sets the `callback` that should be called when any {@link InputEvent} is sent to the window specified by `windowId`.
+     * **Warning:** Advanced users only! Adding such a callback to a {@link Window} node will override its default implementation, which can introduce bugs.
+     */
+    static windowSetInputEventCallback(callback: Callable, windowId?: number /* = 0 */): void { _C($(), 14900, callback, windowId); }
+
+    /**
+     * Sets the `callback` that should be called when text is entered using the virtual keyboard to the window specified by `windowId`.
+     * **Warning:** Advanced users only! Adding such a callback to a {@link Window} node will override its default implementation, which can introduce bugs.
+     */
+    static windowSetInputTextCallback(callback: Callable, windowId?: number /* = 0 */): void { _C($(), 14901, callback, windowId); }
+
+    /**
+     * Sets the `callback` that should be called when files are dropped from the operating system's file manager to the window specified by `windowId`. `callback` should take one {@link PackedStringArray} argument, which is the list of dropped files.
+     * **Warning:** Advanced users only! Adding such a callback to a {@link Window} node will override its default implementation, which can introduce bugs.
+     * **Note:** This method is implemented on Windows, macOS, Linux (X11/Wayland), and Web.
+     */
+    static windowSetDropFilesCallback(callback: Callable, windowId?: number /* = 0 */): void { _C($(), 14892, callback, windowId); }
+
+    /**
+     * Returns the {@link Object.getInstanceId} of the {@link Window} the `windowId` is attached to.
+     */
+    static windowGetAttachedInstanceId(windowId?: number /* = 0 */): number { return _C($(), 14858, windowId) as number; }
+
+    /**
+     * Returns the window's maximum size (in pixels). See also {@link windowSetMaxSize}.
+     */
+    static windowGetMaxSize(windowId?: number /* = 0 */): Vector2i { return _C($(), 14865, windowId) as Vector2i; }
+
+    /**
+     * Sets the maximum size of the window specified by `windowId` in pixels. Normally, the user will not be able to drag the window to make it larger than the specified size. See also {@link windowGetMaxSize}.
+     * **Note:** It's recommended to change this value using {@link Window.maxSize} instead.
+     * **Note:** Using third-party tools, it is possible for users to disable window geometry restrictions and therefore bypass this limit.
+     */
+    static windowSetMaxSize(maxSize: Vector2i, windowId?: number /* = 0 */): void { _C($(), 14902, maxSize, windowId); }
+
+    /**
+     * Returns the window's minimum size (in pixels). See also {@link windowSetMinSize}.
+     */
+    static windowGetMinSize(windowId?: number /* = 0 */): Vector2i { return _C($(), 14866, windowId) as Vector2i; }
+
+    /**
+     * Sets the minimum size for the given window to `minSize` in pixels. Normally, the user will not be able to drag the window to make it smaller than the specified size. See also {@link windowGetMinSize}.
+     * **Note:** It's recommended to change this value using {@link Window.minSize} instead.
+     * **Note:** By default, the main window has a minimum size of `Vector2i(64, 64)`. This prevents issues that can arise when the window is resized to a near-zero size.
+     * **Note:** Using third-party tools, it is possible for users to disable window geometry restrictions and therefore bypass this limit.
+     */
+    static windowSetMinSize(minSize: Vector2i, windowId?: number /* = 0 */): void { _C($(), 14903, minSize, windowId); }
+
+    /**
+     * Returns the size of the window specified by `windowId` (in pixels), including the borders drawn by the operating system. See also {@link windowGetSize}.
+     */
+    static windowGetSizeWithDecorations(windowId?: number /* = 0 */): Vector2i { return _C($(), 14875, windowId) as Vector2i; }
+
+    /**
+     * Returns the mode of the given window.
+     */
+    static windowGetMode(windowId?: number /* = 0 */): WindowMode { return _C($(), 14867, windowId) as WindowMode; }
+
+    /**
+     * Sets window mode for the given window to `mode`.
+     * **Note:** On Android, setting it to {@link WINDOW_MODE_FULLSCREEN} or {@link WINDOW_MODE_EXCLUSIVE_FULLSCREEN} will enable immersive mode.
+     * **Note:** Setting the window to full screen forcibly sets the borderless flag to `true`, so make sure to set it back to `false` when not wanted.
+     */
+    static windowSetMode(mode: WindowMode, windowId?: number /* = 0 */): void { _C($(), 14904, mode, windowId); }
+
+    /**
+     * Enables or disables the given window's given `flag`.
+     */
+    static windowSetFlag(flag: WindowFlags, enabled: boolean, windowId?: number /* = 0 */): void { _C($(), 14894, flag, enabled, windowId); }
+
+    /**
+     * Returns the current value of the given window's `flag`.
+     */
+    static windowGetFlag(flag: WindowFlags, windowId?: number /* = 0 */): boolean { return _C($(), 14860, flag, windowId) as boolean; }
+
+    /**
+     * Sets the window icon (usually displayed in the top-left corner) for the window specified by `windowId`.
+     * **Note:** This method is implemented on Linux and Windows.
+     */
+    static windowSetIcon(icon: Image, windowId?: number /* = 0 */): void { _C($(), 14897, icon, windowId); }
+
+    /**
+     * When {@link WINDOW_FLAG_EXTEND_TO_TITLE} flag is set, set offset to the center of the first titlebar button.
+     * **Note:** This flag is implemented only on macOS.
+     */
+    static windowSetWindowButtonsOffset(offset: Vector2i, windowId?: number /* = 0 */): void { _C($(), 14915, offset, windowId); }
+
+    /**
+     * Returns left margins (`x`), right margins (`y`) and height (`z`) of the title that are safe to use (contains no buttons or other elements) when {@link WINDOW_FLAG_EXTEND_TO_TITLE} flag is set.
+     */
+    static windowGetSafeTitleMargins(windowId?: number /* = 0 */): Vector3i { return _C($(), 14873, windowId) as Vector3i; }
+
+    /**
+     * Makes the window specified by `windowId` 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.
+     */
+    static windowRequestAttention(windowId?: number /* = 0 */): void { _C($(), 14888, windowId); }
+
+    /**
+     * Creates a progress bar on the taskbar/dock icon of the window specified by `windowId` 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.
+     */
+    static windowSetTaskbarProgressValue(value: number, windowId?: number /* = 0 */): void { _C($(), 14911, value, windowId); }
+
+    /**
+     * Sets the type and state of the progress bar on the taskbar/dock icon of the window specified by `windowId`. 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.
+     */
+    static windowSetTaskbarProgressState(state: ProgressState, windowId?: number /* = 0 */): void { _C($(), 14910, state, windowId); }
+
+    /**
+     * Moves the window specified by `windowId` to the foreground, so that it is visible over other windows.
+     */
+    static windowMoveToForeground(windowId?: number /* = 0 */): void { _C($(), 14887, windowId); }
+
+    /**
+     * Returns `true` if the window specified by `windowId` is focused.
+     */
+    static windowIsFocused(windowId?: number /* = 0 */): boolean { return _C($(), 14880, windowId) as boolean; }
+
+    /**
+     * Returns `true` if anything can be drawn in the window specified by `windowId`, `false` otherwise. Using the `--disable-render-loop` command line argument or a headless build will return `false`.
+     */
+    static windowCanDraw(windowId?: number /* = 0 */): boolean { return _C($(), 14856, windowId) as boolean; }
+
+    /**
+     * Sets window transient parent. Transient window will be destroyed with its transient parent and will return focus to their parent when closed. The transient window is displayed on top of a non-exclusive full-screen parent window. Transient windows can't enter full-screen mode.
+     * **Note:** It's recommended to change this value using {@link Window.transient} instead.
+     * **Note:** The behavior might be different depending on the platform.
+     */
+    static windowSetTransient(windowId: number, parentWindowId: number): void { _C($(), 14913, windowId, parentWindowId); }
+
+    /**
+     * If set to `true`, this window will always stay on top of its parent window, parent window will ignore input while this window is opened.
+     * **Note:** On macOS, exclusive windows are confined to the same space (virtual desktop or screen) as the parent window.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static windowSetExclusive(windowId: number, exclusive: boolean): void { _C($(), 14893, windowId, exclusive); }
+
+    /**
+     * Sets whether [Input Method Editor](https://en.wikipedia.org/wiki/Input_method) should be enabled for the window specified by `windowId`. See also {@link windowSetImePosition}.
+     */
+    static windowSetImeActive(active: boolean, windowId?: number /* = 0 */): void { _C($(), 14898, active, windowId); }
+
+    /**
+     * Sets the position of the [Input Method Editor](https://en.wikipedia.org/wiki/Input_method) popup for the specified `windowId`. Only effective if {@link windowSetImeActive} was set to `true` for the specified `windowId`.
+     */
+    static windowSetImePosition(position: Vector2i, windowId?: number /* = 0 */): void { _C($(), 14899, position, windowId); }
+
+    /**
+     * Sets the V-Sync mode of the given window. See also {@link ProjectSettings.display/window/vsync/vsyncMode}.
+     * Depending on the platform and used renderer, the engine will fall back to {@link VSYNC_ENABLED} if the desired mode is not supported.
+     * **Note:** V-Sync modes other than {@link VSYNC_ENABLED} are only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+     */
+    static windowSetVsyncMode(vsyncMode: VSyncMode, windowId?: number /* = 0 */): void { _C($(), 14914, vsyncMode, windowId); }
+
+    /**
+     * Returns the V-Sync mode of the given window.
+     */
+    static windowGetVsyncMode(windowId?: number /* = 0 */): VSyncMode { return _C($(), 14877, windowId) as VSyncMode; }
+
+    /**
+     * Returns `true` if the window specified by `windowId` supports HDR output. This depends on the platform, screen capabilities, system settings, and the screen the window is currently on.
+     */
+    static windowIsHdrOutputSupported(windowId?: number /* = 0 */): boolean { return _C($(), 14883, windowId) as boolean; }
+
+    /**
+     * If `enable` is `true`, HDR output is requested for the window specified by `windowId`. 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.useHdr2d} to be enabled on the main {@link Viewport}. All other {@link SubViewport} of the {@link Window} must have their {@link Viewport.useHdr2d} property enabled to produce HDR output. Corresponds to {@link Window.hdrOutputRequested}.
+     */
+    static windowRequestHdrOutput(enable: boolean, windowId?: number /* = 0 */): void { _C($(), 14889, enable, windowId); }
+
+    /**
+     * Returns `true` if HDR output is requested for the window specified by `windowId`. Corresponds to {@link Window.hdrOutputRequested}.
+     */
+    static windowIsHdrOutputRequested(windowId?: number /* = 0 */): boolean { return _C($(), 14882, windowId) as boolean; }
+
+    /**
+     * Returns `true` if HDR output is currently enabled for the window specified by `windowId`. The returned value may change dynamically based on system settings, screen capabilities, and which screen the window is currently on.
+     */
+    static windowIsHdrOutputEnabled(windowId?: number /* = 0 */): boolean { return _C($(), 14881, windowId) as boolean; }
+
+    /**
+     * Sets the reference white luminance in nits (cd/m²) for HDR output by the window specified by `windowId`. If `referenceLuminance` 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 windowGetHdrOutputCurrentReferenceLuminance} and {@link windowGetHdrOutputReferenceLuminance}.
+     * **Note:** This method is only implemented on Windows. Other platforms will always use the reference luminance that is reported by the operating system.
+     */
+    static windowSetHdrOutputReferenceLuminance(referenceLuminance: number, windowId?: number /* = 0 */): void { _C($(), 14896, referenceLuminance, windowId); }
+
+    /**
+     * Returns the reference white luminance in nits (cd/m²) set for HDR output by the window specified by `windowId`. Negative values indicate that the value is being automatically adjusted to match the operating system brightness. See also {@link windowGetHdrOutputCurrentReferenceLuminance}.
+     */
+    static windowGetHdrOutputReferenceLuminance(windowId?: number /* = 0 */): number { return _C($(), 14864, windowId) as number; }
+
+    /**
+     * When {@link windowIsHdrOutputEnabled} returns `true`, this returns the current reference white luminance in nits (cd/m²) for HDR output by the window specified by `windowId`. 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 windowSetHdrOutputReferenceLuminance}. This reference luminance value is used when calculating {@link windowGetOutputMaxLinearValue}.
+     * **Note:** This reference white luminance may not match the physical behavior of the screen, but will always be proportionally correct relative to {@link windowGetHdrOutputCurrentMaxLuminance}.
+     */
+    static windowGetHdrOutputCurrentReferenceLuminance(windowId?: number /* = 0 */): number { return _C($(), 14862, windowId) as number; }
+
+    /**
+     * Sets the maximum luminance in nits (cd/m²) for HDR output by the window specified by `windowId`. If `maxLuminance` 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 windowGetHdrOutputCurrentMaxLuminance} and {@link windowGetHdrOutputMaxLuminance}.
+     * **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.
+     */
+    static windowSetHdrOutputMaxLuminance(maxLuminance: number, windowId?: number /* = 0 */): void { _C($(), 14895, maxLuminance, windowId); }
+
+    /**
+     * Returns the maximum luminance in nits (cd/m²) set for HDR output by the window specified by `windowId`. Negative values indicate that the value is being automatically adjusted based on the screen's capabilities. See also {@link windowGetHdrOutputCurrentMaxLuminance}.
+     */
+    static windowGetHdrOutputMaxLuminance(windowId?: number /* = 0 */): number { return _C($(), 14863, windowId) as number; }
+
+    /**
+     * When {@link windowIsHdrOutputEnabled} returns `true`, this returns the current maximum luminance in nits (cd/m²) for HDR output by the window specified by `windowId`. 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 windowSetHdrOutputMaxLuminance}. This maximum luminance value is used when calculating {@link windowGetOutputMaxLinearValue}.
+     * **Note:** This maximum luminance may not match the physical behavior of the screen, but will always be proportionally correct relative to {@link windowGetHdrOutputCurrentReferenceLuminance}.
+     */
+    static windowGetHdrOutputCurrentMaxLuminance(windowId?: number /* = 0 */): number { return _C($(), 14861, windowId) as number; }
+
+    /**
+     * Returns the maximum value for linear color components that can be displayed for the window specified by `windowId`, 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 windowGetHdrOutputCurrentReferenceLuminance} and {@link windowGetHdrOutputCurrentMaxLuminance}. 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.getOutputMaxLinearValue}.
+     */
+    static windowGetOutputMaxLinearValue(windowId?: number /* = 0 */): number { return _C($(), 14869, windowId) as number; }
+
+    /**
+     * Returns `true` if the given window can be maximized (the maximize button is enabled).
+     */
+    static windowIsMaximizeAllowed(windowId?: number /* = 0 */): boolean { return _C($(), 14884, windowId) as boolean; }
+
+    /**
+     * Returns `true` if double-clicking on a window's title should maximize it.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static windowMaximizeOnTitleDblClick(): boolean { return _C($(), 14885) as boolean; }
+
+    /**
+     * Returns `true` if double-clicking on a window's title should minimize it.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static windowMinimizeOnTitleDblClick(): boolean { return _C($(), 14886) as boolean; }
+
+    /**
+     * Starts an interactive drag operation on the window with the given `windowId`, using the current mouse position. Call this method when handling a mouse button being pressed to simulate a pressed event on the window's title bar. Using this method allows the window to participate in space switching, tiling, and other system features.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS, and Windows.
+     */
+    static windowStartDrag(windowId?: number /* = 0 */): void { _C($(), 14917, windowId); }
+
+    /**
+     * Starts an interactive resize operation on the window with the given `windowId`, using the current mouse position. Call this method when handling a mouse button being pressed to simulate a pressed event on the window's edge.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS, and Windows.
+     */
+    static windowStartResize(edge: WindowResizeEdge, windowId?: number /* = 0 */): void { _C($(), 14918, edge, windowId); }
+
+    /**
+     * Sets the background color of the root window.
+     * **Note:** This method is implemented only on Android.
+     */
+    static windowSetColor(color: Color): void { _C($(), 14890, color); }
+
+    /**
+     * Returns `1` if a high-contrast user interface theme should be used, `0` otherwise. Returns `-1` if status is unknown.
+     * **Note:** This method is implemented on Linux (X11/Wayland, GNOME), macOS, and Windows.
+     */
+    static accessibilityShouldIncreaseContrast(): number { return _C($(), 1084) as number; }
+
+    /**
+     * Returns `1` if flashing, blinking, and other moving content that can cause seizures in users with photosensitive epilepsy should be disabled, `0` otherwise. Returns `-1` if status is unknown.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static accessibilityShouldReduceAnimation(): number { return _C($(), 1085) as number; }
+
+    /**
+     * Returns `1` if background images, transparency, and other features that can reduce the contrast between the foreground and background should be disabled, `0` otherwise. Returns `-1` if status is unknown.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static accessibilityShouldReduceTransparency(): number { return _C($(), 1086) as number; }
+
+    /**
+     * Returns `1` if a screen reader, Braille display or other assistive app is active, `0` otherwise. Returns `-1` if status is unknown.
+     * **Note:** This method is implemented on Linux, macOS, and Windows.
+     * **Note:** Accessibility debugging tools, such as Accessibility Insights for Windows, Accessibility Inspector (macOS), or AT-SPI Browser (Linux/BSD), do not count as assistive apps and will not affect this value. To test your project with these tools, set {@link ProjectSettings.accessibility/general/accessibilitySupport} to `1`.
+     */
+    static accessibilityScreenReaderActive(): number { return _C($(), 1081) as number; }
+
+    /**
+     * Creates a new, empty accessibility element resource.
+     * **Note:** An accessibility element is created and freed automatically for each {@link Node}. In general, this function should not be called manually.
+     */
+    static accessibilityCreateElement(windowId: number, role: AccessibilityRole): RID { return _C($(), 1064, windowId, role) as RID; }
+
+    /**
+     * Creates a new, empty accessibility sub-element resource. Sub-elements can be used to provide accessibility information for objects which are not {@link Node}s, such as list items, table cells, or menu items. Sub-elements are freed automatically when the parent element is freed, or can be freed early using the {@link accessibilityFreeElement} method.
+     */
+    static accessibilityCreateSubElement(parentRid: RID, role: AccessibilityRole, insertPos?: number /* = -1 */): RID { return _C($(), 1065, parentRid, role, insertPos) as RID; }
+
+    /**
+     * Creates a new, empty accessibility sub-element from the shaped text buffer. Sub-elements are freed automatically when the parent element is freed, or can be freed early using the {@link accessibilityFreeElement} method.
+     * If `isLastLine` is `true`, no trailing newline is appended to the text content. Set to `true` for the last line in multi-line text fields and for single-line text fields.
+     */
+    static accessibilityCreateSubTextEditElements(parentRid: RID, shapedText: RID, minHeight: number, insertPos?: number /* = -1 */, isLastLine?: boolean /* = false */): RID { return _C($(), 1066, parentRid, shapedText, minHeight, insertPos, isLastLine) as RID; }
+
+    /**
+     * Returns `true` if `id` is a valid accessibility element.
+     */
+    static accessibilityHasElement(id: RID): boolean { return _C($(), 1076, id) as boolean; }
+
+    /**
+     * Frees the accessibility element `id` created by {@link accessibilityCreateElement}, {@link accessibilityCreateSubElement}, or {@link accessibilityCreateSubTextEditElements}.
+     */
+    static accessibilityFreeElement(id: RID): void { _C($(), 1074, id); }
+
+    /**
+     * Sets the metadata of the accessibility element `id` to `meta`.
+     */
+    static accessibilityElementSetMeta(id: RID, meta: Variant): void { _C($(), 1072, id, meta); }
+
+    /**
+     * Returns the metadata of the accessibility element `id`.
+     */
+    static accessibilityElementGetMeta(id: RID): Variant { return _C($(), 1071, id) as Variant; }
+
+    /**
+     * Sets window outer (with decorations) and inner (without decorations) bounds for assistive apps.
+     * **Note:** This method is implemented on Linux, macOS, and Windows.
+     * **Note:** Advanced users only! {@link Window} objects call this method automatically.
+     */
+    static accessibilitySetWindowRect(windowId: number, rectOut: Rect2, rectIn: Rect2): void { _C($(), 1083, windowId, rectOut, rectIn); }
+
+    /**
+     * Sets the window focused state for assistive apps.
+     * **Note:** This method is implemented on Linux, macOS, and Windows.
+     * **Note:** Advanced users only! {@link Window} objects call this method automatically.
+     */
+    static accessibilitySetWindowFocused(windowId: number, focused: boolean): void { _C($(), 1082, windowId, focused); }
+
+    /**
+     * Sets currently focused element.
+     */
+    static accessibilityUpdateSetFocus(id: RID): void { _C($(), 1106, id); }
+
+    /**
+     * Returns the main accessibility element of the OS native window.
+     */
+    static accessibilityGetWindowRoot(windowId: number): RID { return _C($(), 1075, windowId) as RID; }
+
+    /**
+     * Sets element accessibility role.
+     */
+    static accessibilityUpdateSetRole(id: RID, role: AccessibilityRole): void { _C($(), 1127, id, role); }
+
+    /**
+     * Sets element accessibility name.
+     */
+    static accessibilityUpdateSetName(id: RID, name: string): void { _C($(), 1118, id, name); }
+
+    /**
+     * Sets element accessibility extra information added to the element name.
+     */
+    static accessibilityUpdateSetExtraInfo(id: RID, name: string): void { _C($(), 1104, id, name); }
+
+    /**
+     * Sets element accessibility description.
+     */
+    static accessibilityUpdateSetDescription(id: RID, description: string): void { _C($(), 1102, id, description); }
+
+    /**
+     * Sets element text value.
+     */
+    static accessibilityUpdateSetValue(id: RID, value: string): void { _C($(), 1148, id, value); }
+
+    /**
+     * Sets tooltip text.
+     */
+    static accessibilityUpdateSetTooltip(id: RID, tooltip: string): void { _C($(), 1145, id, tooltip); }
+
+    /**
+     * Sets element bounding box, relative to the node position.
+     */
+    static accessibilityUpdateSetBounds(id: RID, rect: Rect2): void { _C($(), 1098, id, rect); }
+
+    /**
+     * Sets element 2D transform.
+     */
+    static accessibilityUpdateSetTransform(id: RID, transform: Transform2D): void { _C($(), 1146, id, transform); }
+
+    /**
+     * Adds a child accessibility element.
+     * **Note:** {@link Node} children and sub-elements are added to the child list automatically.
+     */
+    static accessibilityUpdateAddChild(id: RID, childId: RID): void { _C($(), 1088, id, childId); }
+
+    /**
+     * Adds an element that is controlled by this element.
+     */
+    static accessibilityUpdateAddRelatedControls(id: RID, relatedId: RID): void { _C($(), 1090, id, relatedId); }
+
+    /**
+     * Adds an element that details this element.
+     */
+    static accessibilityUpdateAddRelatedDetails(id: RID, relatedId: RID): void { _C($(), 1092, id, relatedId); }
+
+    /**
+     * Adds an element that describes this element.
+     */
+    static accessibilityUpdateAddRelatedDescribedBy(id: RID, relatedId: RID): void { _C($(), 1091, id, relatedId); }
+
+    /**
+     * Adds an element that this element flow into.
+     */
+    static accessibilityUpdateAddRelatedFlowTo(id: RID, relatedId: RID): void { _C($(), 1093, id, relatedId); }
+
+    /**
+     * Adds an element that labels this element.
+     */
+    static accessibilityUpdateAddRelatedLabeledBy(id: RID, relatedId: RID): void { _C($(), 1094, id, relatedId); }
+
+    /**
+     * Adds an element that is part of the same radio group.
+     * **Note:** This method should be called on each element of the group, using all other elements as `relatedId`.
+     */
+    static accessibilityUpdateAddRelatedRadioGroup(id: RID, relatedId: RID): void { _C($(), 1095, id, relatedId); }
+
+    /**
+     * Adds an element that is an active descendant of this element.
+     */
+    static accessibilityUpdateSetActiveDescendant(id: RID, otherId: RID): void { _C($(), 1096, id, otherId); }
+
+    /**
+     * Sets next element on the line.
+     */
+    static accessibilityUpdateSetNextOnLine(id: RID, otherId: RID): void { _C($(), 1119, id, otherId); }
+
+    /**
+     * Sets previous element on the line.
+     */
+    static accessibilityUpdateSetPreviousOnLine(id: RID, otherId: RID): void { _C($(), 1126, id, otherId); }
+
+    /**
+     * Sets the element to be a member of the group.
+     */
+    static accessibilityUpdateSetMemberOf(id: RID, groupId: RID): void { _C($(), 1117, id, groupId); }
+
+    /**
+     * Sets target element for the link.
+     */
+    static accessibilityUpdateSetInPageLinkTarget(id: RID, otherId: RID): void { _C($(), 1108, id, otherId); }
+
+    /**
+     * Sets an element which contains an error message for this element.
+     */
+    static accessibilityUpdateSetErrorMessage(id: RID, otherId: RID): void { _C($(), 1103, id, otherId); }
+
+    /**
+     * Sets the priority of the live region updates.
+     */
+    static accessibilityUpdateSetLive(id: RID, live: AccessibilityLiveMode): void { _C($(), 1116, id, live); }
+
+    /**
+     * Adds a callback for the accessibility action (action which can be performed by using a special screen reader command or buttons on the Braille display), and marks this action as supported. The action callback receives one {@link Variant} argument, which value depends on action type.
+     */
+    static accessibilityUpdateAddAction(id: RID, action: AccessibilityAction, callable: Callable): void { _C($(), 1087, id, action, callable); }
+
+    /**
+     * Adds support for a custom accessibility action. `actionId` is passed as an argument to the callback of {@link ACTION_CUSTOM} action.
+     */
+    static accessibilityUpdateAddCustomAction(id: RID, actionId: number, actionDescription: string): void { _C($(), 1089, id, actionId, actionDescription); }
+
+    /**
+     * Sets number of rows in the table.
+     */
+    static accessibilityUpdateSetTableRowCount(id: RID, count: number): void { _C($(), 1139, id, count); }
+
+    /**
+     * Sets number of columns in the table.
+     */
+    static accessibilityUpdateSetTableColumnCount(id: RID, count: number): void { _C($(), 1137, id, count); }
+
+    /**
+     * Sets position of the row in the table.
+     */
+    static accessibilityUpdateSetTableRowIndex(id: RID, index: number): void { _C($(), 1140, id, index); }
+
+    /**
+     * Sets position of the column.
+     */
+    static accessibilityUpdateSetTableColumnIndex(id: RID, index: number): void { _C($(), 1138, id, index); }
+
+    /**
+     * Sets cell position in the table.
+     */
+    static accessibilityUpdateSetTableCellPosition(id: RID, rowIndex: number, columnIndex: number): void { _C($(), 1135, id, rowIndex, columnIndex); }
+
+    /**
+     * Sets cell row/column span.
+     */
+    static accessibilityUpdateSetTableCellSpan(id: RID, rowSpan: number, columnSpan: number): void { _C($(), 1136, id, rowSpan, columnSpan); }
+
+    /**
+     * Sets number of items in the list.
+     */
+    static accessibilityUpdateSetListItemCount(id: RID, size: number): void { _C($(), 1110, id, size); }
+
+    /**
+     * Sets the position of the element in the list.
+     */
+    static accessibilityUpdateSetListItemIndex(id: RID, index: number): void { _C($(), 1112, id, index); }
+
+    /**
+     * Sets the hierarchical level of the element in the list.
+     */
+    static accessibilityUpdateSetListItemLevel(id: RID, level: number): void { _C($(), 1113, id, level); }
+
+    /**
+     * Sets list/tree item selected status.
+     */
+    static accessibilityUpdateSetListItemSelected(id: RID, selected: boolean): void { _C($(), 1114, id, selected); }
+
+    /**
+     * Sets list/tree item expanded status.
+     */
+    static accessibilityUpdateSetListItemExpanded(id: RID, expanded: boolean): void { _C($(), 1111, id, expanded); }
+
+    /**
+     * Sets popup type for popup buttons.
+     */
+    static accessibilityUpdateSetPopupType(id: RID, popup: AccessibilityPopupType): void { _C($(), 1125, id, popup); }
+
+    /**
+     * Sets element checked state.
+     */
+    static accessibilityUpdateSetChecked(id: RID, checekd: boolean): void { _C($(), 1099, id, checekd); }
+
+    /**
+     * Sets numeric value.
+     */
+    static accessibilityUpdateSetNumValue(id: RID, position: number /* double */): void { _C($(), 1123, id, position); }
+
+    /**
+     * Sets numeric value range.
+     */
+    static accessibilityUpdateSetNumRange(id: RID, min: number /* double */, max: number /* double */): void { _C($(), 1121, id, min, max); }
+
+    /**
+     * Sets numeric value step.
+     */
+    static accessibilityUpdateSetNumStep(id: RID, step: number /* double */): void { _C($(), 1122, id, step); }
+
+    /**
+     * Sets numeric value jump.
+     */
+    static accessibilityUpdateSetNumJump(id: RID, jump: number /* double */): void { _C($(), 1120, id, jump); }
+
+    /**
+     * Sets scroll bar x position.
+     */
+    static accessibilityUpdateSetScrollX(id: RID, position: number /* double */): void { _C($(), 1129, id, position); }
+
+    /**
+     * Sets scroll bar x range.
+     */
+    static accessibilityUpdateSetScrollXRange(id: RID, min: number /* double */, max: number /* double */): void { _C($(), 1130, id, min, max); }
+
+    /**
+     * Sets scroll bar y position.
+     */
+    static accessibilityUpdateSetScrollY(id: RID, position: number /* double */): void { _C($(), 1131, id, position); }
+
+    /**
+     * Sets scroll bar y range.
+     */
+    static accessibilityUpdateSetScrollYRange(id: RID, min: number /* double */, max: number /* double */): void { _C($(), 1132, id, min, max); }
+
+    /**
+     * Sets text underline/overline/strikethrough.
+     */
+    static accessibilityUpdateSetTextDecorations(id: RID, underline: boolean, strikethrough: boolean, overline: boolean): void { _C($(), 1142, id, underline, strikethrough, overline); }
+
+    /**
+     * Sets element text alignment.
+     */
+    static accessibilityUpdateSetTextAlign(id: RID, align: HorizontalAlignment): void { _C($(), 1141, id, align); }
+
+    /**
+     * Sets text selection to the text field. `textStartId` and `textEndId` should be elements created by {@link accessibilityCreateSubTextEditElements}. Character offsets are relative to the corresponding element.
+     */
+    static accessibilityUpdateSetTextSelection(id: RID, textStartId: RID, startChar: number, textEndId: RID, endChar: number): void { _C($(), 1144, id, textStartId, startChar, textEndId, endChar); }
+
+    /**
+     * Sets element flag.
+     */
+    static accessibilityUpdateSetFlag(id: RID, flag: AccessibilityFlags, value: boolean): void { _C($(), 1105, id, flag, value); }
+
+    /**
+     * Sets element class name.
+     */
+    static accessibilityUpdateSetClassname(id: RID, classname: string): void { _C($(), 1100, id, classname); }
+
+    /**
+     * Sets placeholder text.
+     */
+    static accessibilityUpdateSetPlaceholder(id: RID, placeholder: string): void { _C($(), 1124, id, placeholder); }
+
+    /**
+     * Sets element text language.
+     */
+    static accessibilityUpdateSetLanguage(id: RID, language: string): void { _C($(), 1109, id, language); }
+
+    /**
+     * Sets text orientation.
+     */
+    static accessibilityUpdateSetTextOrientation(id: RID, vertical: boolean): void { _C($(), 1143, id, vertical); }
+
+    /**
+     * Sets the orientation of the list elements.
+     */
+    static accessibilityUpdateSetListOrientation(id: RID, vertical: boolean): void { _C($(), 1115, id, vertical); }
+
+    /**
+     * Sets the list of keyboard shortcuts used by element.
+     */
+    static accessibilityUpdateSetShortcut(id: RID, shortcut: string): void { _C($(), 1133, id, shortcut); }
+
+    /**
+     * Sets link URL.
+     */
+    static accessibilityUpdateSetUrl(id: RID, url: string): void { _C($(), 1147, id, url); }
+
+    /**
+     * Sets element accessibility role description text.
+     */
+    static accessibilityUpdateSetRoleDescription(id: RID, description: string): void { _C($(), 1128, id, description); }
+
+    /**
+     * Sets human-readable description of the current checked state.
+     */
+    static accessibilityUpdateSetStateDescription(id: RID, description: string): void { _C($(), 1134, id, description); }
+
+    /**
+     * Sets element color value.
+     */
+    static accessibilityUpdateSetColorValue(id: RID, color: Color): void { _C($(), 1101, id, color); }
+
+    /**
+     * Sets element background color.
+     */
+    static accessibilityUpdateSetBackgroundColor(id: RID, color: Color): void { _C($(), 1097, id, color); }
+
+    /**
+     * Sets element foreground color.
+     */
+    static accessibilityUpdateSetForegroundColor(id: RID, color: Color): void { _C($(), 1107, id, color); }
+
+    /**
+     * Returns the text selection in the [Input Method Editor](https://en.wikipedia.org/wiki/Input_method) composition string, with the {@link Vector2i}'s `x` component being the caret position and `y` being the length of the selection.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static imeGetSelection(): Vector2i { return _C($(), 7574) as Vector2i; }
+
+    /**
+     * Returns the composition string contained within the [Input Method Editor](https://en.wikipedia.org/wiki/Input_method) window.
+     * **Note:** This method is implemented only on macOS.
+     */
+    static imeGetText(): string { return _C($(), 7575) as string; }
+
+    /**
+     * Shows the virtual keyboard if the platform has one.
+     * `existingText` parameter is useful for implementing your own {@link LineEdit} or {@link TextEdit}, as it tells the virtual keyboard what text has already been typed (the virtual keyboard uses it for auto-correct and predictions).
+     * `position` parameter is the screen space {@link Rect2} of the edited text.
+     * `type` parameter allows configuring which type of virtual keyboard to show.
+     * `maxLength` limits the number of characters that can be entered if different from `-1`.
+     * `cursorStart` can optionally define the current text cursor position if `cursorEnd` is not set.
+     * `cursorStart` and `cursorEnd` can optionally define the current text selection.
+     * **Note:** This method is implemented on Android, iOS and Web.
+     */
+    static virtualKeyboardShow(existingText: string, position?: Rect2 /* = Rect2(0, 0, 0, 0) */, type?: VirtualKeyboardType /* = 0 */, maxLength?: number /* = -1 */, cursorStart?: number /* = -1 */, cursorEnd?: number /* = -1 */): void { _C($(), 14768, existingText, position, type, maxLength, cursorStart, cursorEnd); }
+
+    /**
+     * Hides the virtual keyboard if it is shown, does nothing otherwise.
+     */
+    static virtualKeyboardHide(): void { _C($(), 14767); }
+
+    /**
+     * Returns the on-screen keyboard's height in pixels. Returns `0` if there is no keyboard or if it is currently hidden.
+     * **Note:** On Android 7 and 8, the keyboard height may return `0` the first time the keyboard is opened in non-immersive mode. This behavior does not occur in immersive mode.
+     */
+    static virtualKeyboardGetHeight(): number { return _C($(), 14766) as number; }
+
+    /**
+     * Returns `true` if a hardware keyboard is connected.
+     * **Note:** This method is implemented on Android and iOS. On other platforms, this method always returns `true`.
+     */
+    static hasHardwareKeyboard(): boolean { return _C($(), 7401) as boolean; }
+
+    /**
+     * Sets the callback that should be called when a hardware keyboard is connected or disconnected. `callable` should accept a single {@link bool} argument indicating whether the keyboard has been connected (`true`) or disconnected (`false`).
+     * **Note:** This method is only implemented on Android.
+     */
+    static setHardwareKeyboardConnectionChangeCallback(callable: Callable): void { _C($(), 11605, callable); }
+
+    /**
+     * Sets the default mouse cursor shape. The cursor's appearance will vary depending on the user's operating system and mouse cursor theme. See also {@link cursorGetShape} and {@link cursorSetCustomImage}.
+     */
+    static cursorSetShape(shape: CursorShape): void { _C($(), 2611, shape); }
+
+    /**
+     * Returns the default mouse cursor shape set by {@link cursorSetShape}.
+     */
+    static cursorGetShape(): CursorShape { return _C($(), 2609) as CursorShape; }
+
+    /**
+     * Sets a custom mouse cursor image for the given `shape`. This means the user's operating system and mouse cursor theme will no longer influence the mouse cursor's appearance.
+     * `cursor` can be either a {@link Texture2D} or an {@link Image}, and it should not be larger than 256×256 to display correctly. Optionally, `hotspot` can be set to offset the image's position relative to the click point. By default, `hotspot` is set to the top-left corner of the image. See also {@link cursorSetShape}.
+     * **Note:** On Web, calling this method every frame can cause the cursor to flicker.
+     */
+    static cursorSetCustomImage(cursor: Resource, shape?: CursorShape /* = 0 */, hotspot?: Vector2 /* = Vector2(0, 0) */): void { _C($(), 2610, cursor, shape, hotspot); }
+
+    /**
+     * Returns `true` if positions of **OK** and **Cancel** buttons are swapped in dialogs. This is enabled by default on Windows to follow interface conventions, and be toggled by changing {@link ProjectSettings.gui/common/swapCancelOk}.
+     * **Note:** This doesn't affect native dialogs such as the ones spawned by {@link DisplayServer.dialogShow}.
+     */
+    static getSwapCancelOk(): boolean { return _C($(), 6642) as boolean; }
+
+    /**
+     * Allows the `processId` PID to steal focus from this window. In other words, this disables the operating system's focus stealing protection for the specified PID.
+     * **Note:** This method is implemented only on Windows.
+     */
+    static enableForStealingFocus(processId: number /* int64 */): void { _C($(), 3066, processId); }
+
+    /**
+     * Shows a text dialog which uses the operating system's native look-and-feel. `callback` should accept a single {@link int} parameter which corresponds to the index of the pressed button.
+     * **Note:** This method is implemented if the display server has the {@link FEATURE_NATIVE_DIALOG} feature. Supported platforms include macOS, Windows, and Android.
+     */
+    static dialogShow(title: string, description: string, buttons: PackedStringArray, callback: Callable): Error { return _C($(), 2781, title, description, buttons, callback) as Error; }
+
+    /**
+     * Shows a text input dialog which uses the operating system's native look-and-feel. `callback` should accept a single {@link String} parameter which contains the text field's contents.
+     * **Note:** This method is implemented if the display server has the {@link FEATURE_NATIVE_DIALOG_INPUT} feature. Supported platforms include macOS, Windows, and Android.
+     */
+    static dialogInputText(title: string, description: string, existingText: string, callback: Callable): Error { return _C($(), 2780, title, description, existingText, callback) as Error; }
+
+    /**
+     * 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.
+     * **Note:** `currentDirectory` 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, `showHidden` is ignored.
+     * **Note:** On Android and macOS, native file dialogs have no title.
+     * **Note:** On macOS, sandboxed apps will save security-scoped bookmarks to retain access to the opened folders across multiple sessions. Use {@link OS.getGrantedPermissions} to get a list of saved bookmarks.
+     * **Note:** On Android, this method uses the Android Storage Access Framework (SAF).
+     * The file picker returns a URI instead of a filesystem path. This URI can be passed directly to {@link FileAccess} to perform read/write operations.
+     * When using {@link FILE_DIALOG_MODE_OPEN_DIR}, it returns a tree URI that grants full access to the selected directory. File operations inside this directory can be performed by passing a path on the form `treeUri#relative/path/to/file` to {@link FileAccess}.
+     * To avoid opening the file picker again after each app restart, you can take persistable URI permission as follows:
+     *
+     *
+     * ```gdscript
+     *
+     * val uri = "content://com.android..." # URI of the selected file or folder.
+     * val persist = true # Set to false to release the persistable permission.
+     * var android_runtime = Engine.get_singleton("AndroidRuntime")
+     * android_runtime.updatePersistableUriPermission(uri, persist)
+     *
+     * ```
+     *
+     *
+     * The persistable URI permission remains valid across app restarts as long as the directory is not moved, renamed, or deleted.
+     */
+    static fileDialogShow(title: string, currentDirectory: string, filename: string, showHidden: boolean, mode: FileDialogMode, filters: PackedStringArray, callback: Callable, parentWindowId?: number /* = 0 */): Error { return _C($(), 3246, title, currentDirectory, filename, showHidden, mode, filters, callback, parentWindowId) as Error; }
+
+    /**
+     * Displays OS native dialog for selecting files or directories in the file system with additional user selectable options.
+     * 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}.
+     * `options` is array of {@link Dictionary}s with the following keys:
+     * - `"name"` - option's name {@link String}.
+     * - `"values"` - {@link PackedStringArray} of values. If empty, boolean option (check box) is used.
+     * - `"default"` - default selected option index ({@link int}) or default boolean value ({@link bool}).
+     * Callbacks have the following arguments: `status: bool, selected_paths: PackedStringArray, selected_filter_index: int, selected_option: Dictionary`.
+     * **Note:** This method is implemented if the display server has the {@link FEATURE_NATIVE_DIALOG_FILE_EXTRA} feature. Supported platforms include Linux (X11/Wayland), Windows, and macOS.
+     * **Note:** `currentDirectory` 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 Linux (X11), `showHidden` is ignored.
+     * **Note:** On macOS, native file dialogs have no title.
+     * **Note:** On macOS, sandboxed apps will save security-scoped bookmarks to retain access to the opened folders across multiple sessions. Use {@link OS.getGrantedPermissions} to get a list of saved bookmarks.
+     */
+    static fileDialogWithOptionsShow(title: string, currentDirectory: string, root: string, filename: string, showHidden: boolean, mode: FileDialogMode, filters: PackedStringArray, options: GodotArray<GodotDictionary>, callback: Callable, parentWindowId?: number /* = 0 */): Error { return _C($(), 3247, title, currentDirectory, root, filename, showHidden, mode, filters, options, callback, parentWindowId) as Error; }
+
+    /**
+     * Plays the beep sound from the operative system, if possible. Because it comes from the OS, the beep sound will be audible even if the application is muted. It may also be disabled for the entire OS by the user.
+     * **Note:** This method is implemented on macOS, Linux (X11/Wayland), and Windows.
+     */
+    static beep(): void { _C($(), 1744); }
+
+    /**
+     * Returns the number of keyboard layouts.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS and Windows.
+     */
+    static keyboardGetLayoutCount(): number { return _C($(), 8525) as number; }
+
+    /**
+     * Returns active keyboard layout index.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS, and Windows.
+     */
+    static keyboardGetCurrentLayout(): number { return _C($(), 8522) as number; }
+
+    /**
+     * Sets the active keyboard layout.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS and Windows.
+     */
+    static keyboardSetCurrentLayout(index: number): void { _C($(), 8528, index); }
+
+    /**
+     * Returns the ISO-639/BCP-47 language code of the keyboard layout at position `index`.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS and Windows.
+     */
+    static keyboardGetLayoutLanguage(index: number): string { return _C($(), 8526, index) as string; }
+
+    /**
+     * Returns the localized name of the keyboard layout at position `index`.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS and Windows.
+     */
+    static keyboardGetLayoutName(index: number): string { return _C($(), 8527, index) as string; }
+
+    /**
+     * Converts a physical (US QWERTY) `keycode` to one in the active keyboard layout.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS and Windows.
+     */
+    static keyboardGetKeycodeFromPhysical(keycode: Key): Key { return _C($(), 8523, keycode) as Key; }
+
+    /**
+     * Converts a physical (US QWERTY) `keycode` to localized label printed on the key in the active keyboard layout.
+     * **Note:** This method is implemented on Linux (X11/Wayland), macOS and Windows.
+     */
+    static keyboardGetLabelFromPhysical(keycode: Key): Key { return _C($(), 8524, keycode) as Key; }
+
+    /**
+     * Opens system emoji and symbol picker.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static showEmojiAndSymbolPicker(): void { _C($(), 13576); }
+
+    /**
+     * Displays OS native color picker.
+     * Callbacks have the following arguments: `status: bool, color: Color`.
+     * **Note:** This method is implemented if the display server has the {@link FEATURE_NATIVE_COLOR_PICKER} feature.
+     * **Note:** This method is only implemented on Linux (X11/Wayland).
+     */
+    static colorPicker(callback: Callable): boolean { return _C($(), 2374, callback) as boolean; }
+
+    /**
+     * Perform window manager processing, including input flushing. See also {@link forceProcessAndDropEvents}, {@link Input.flushBufferedEvents} and {@link Input.useAccumulatedInput}.
+     */
+    static processEvents(): void { _C($(), 9571); }
+
+    /**
+     * Forces window manager processing while ignoring all {@link InputEvent}s. See also {@link processEvents}.
+     * **Note:** This method is implemented on Windows and macOS.
+     */
+    static forceProcessAndDropEvents(): void { _C($(), 3533); }
+
+    /**
+     * Sets the window icon (usually displayed in the top-left corner) in the operating system's *native* format. The file at `filename` must be in `.ico` format on Windows or `.icns` on macOS. By using specially crafted `.ico` or `.icns` icons, {@link setNativeIcon} allows specifying different icons depending on the size the icon is displayed at. This size is determined by the operating system and user preferences (including the display scale factor). To use icons in other formats, use {@link setIcon} instead.
+     * **Note:** Requires support for {@link FEATURE_NATIVE_ICON}.
+     */
+    static setNativeIcon(filename: string): void { _C($(), 12114, filename); }
+
+    /**
+     * 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 setNativeIcon} instead.
+     * **Note:** Requires support for {@link FEATURE_ICON}.
+     */
+    static setIcon(image: Image): void { _C($(), 11645, image); }
+
+    /**
+     * Creates a new application status indicator with the specified icon, tooltip, and activation callback.
+     * `callback` should take two arguments: the pressed mouse button (one of the {@link MouseButton} constants) and the click position in screen coordinates (a {@link Vector2i}).
+     */
+    static createStatusIndicator(icon: Texture2D, tooltip: string, callback: Callable): number { return _C($(), 2573, icon, tooltip, callback) as number; }
+
+    /**
+     * Sets the application status indicator icon.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static statusIndicatorSetIcon(id: number, icon: Texture2D): void { _C($(), 13851, id, icon); }
+
+    /**
+     * Sets the application status indicator tooltip.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static statusIndicatorSetTooltip(id: number, tooltip: string): void { _C($(), 13853, id, tooltip); }
+
+    /**
+     * Sets the application status indicator native popup menu.
+     * **Note:** On macOS, the menu is activated by any mouse button. Its activation callback is *not* triggered.
+     * **Note:** On Windows, the menu is activated by the right mouse button, selecting the status icon and pressing `Shift + F10`, or the applications key. The menu's activation callback for the other mouse buttons is still triggered.
+     * **Note:** Native popup is only supported if {@link NativeMenu} supports the {@link NativeMenu.FEATURE_POPUP_MENU} feature.
+     */
+    static statusIndicatorSetMenu(id: number, menuRid: RID): void { _C($(), 13852, id, menuRid); }
+
+    /**
+     * Sets the application status indicator activation callback. `callback` should take two arguments: {@link int} mouse button index (one of {@link MouseButton} values) and {@link Vector2i} click position in screen coordinates.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static statusIndicatorSetCallback(id: number, callback: Callable): void { _C($(), 13850, id, callback); }
+
+    /**
+     * Returns the rectangle for the given status indicator `id` in screen coordinates. If the status indicator is not visible, returns an empty {@link Rect2}.
+     * **Note:** This method is implemented on macOS and Windows.
+     */
+    static statusIndicatorGetRect(id: number): Rect2 { return _C($(), 13849, id) as Rect2; }
+
+    /**
+     * Removes the application status indicator.
+     */
+    static deleteStatusIndicator(id: number): void { _C($(), 2727, id); }
+
+    /**
+     * Returns the total number of available tablet drivers.
+     * **Note:** This method is implemented only on Windows.
+     */
+    static tabletGetDriverCount(): number { return _C($(), 14105) as number; }
+
+    /**
+     * Returns the tablet driver name for the given index.
+     * **Note:** This method is implemented only on Windows.
+     */
+    static tabletGetDriverName(idx: number): string { return _C($(), 14106, idx) as string; }
+
+    /**
+     * Returns current active tablet driver name.
+     * **Note:** This method is implemented only on Windows.
+     */
+    static tabletGetCurrentDriver(): string { return _C($(), 14104) as string; }
+
+    /**
+     * Set active tablet driver name.
+     * Supported drivers:
+     * - `winink`: Windows Ink API, default.
+     * - `wintab`: Wacom Wintab API (compatible device driver required).
+     * - `dummy`: Dummy driver, tablet input is disabled.
+     * **Note:** This method is implemented only on Windows.
+     */
+    static tabletSetCurrentDriver(name: string): void { _C($(), 14107, name); }
+
+    /**
+     * Returns `true` if the window background can be made transparent. This method returns `false` if {@link ProjectSettings.display/window/perPixelTransparency/allowed} is set to `false`, or if transparency is not supported by the renderer or OS compositor.
+     */
+    static isWindowTransparencyAvailable(): boolean { return _C($(), 8454) as boolean; }
+
+    /**
+     * Registers an {@link Object} which represents an additional output that will be rendered too, beyond normal windows. The {@link Object} is only used as an identifier, which can be later passed to {@link unregisterAdditionalOutput}.
+     * This can be used to prevent Godot from skipping rendering when no normal windows are visible.
+     */
+    static registerAdditionalOutput(object: Object): void { _C($(), 9841, object); }
+
+    /**
+     * Unregisters an {@link Object} representing an additional output, that was registered via {@link registerAdditionalOutput}.
+     */
+    static unregisterAdditionalOutput(object: Object): void { _C($(), 14487, object); }
+
+    /**
+     * Returns `true` if any additional outputs have been registered via {@link registerAdditionalOutput}.
+     */
+    static hasAdditionalOutputs(): boolean { return _C($(), 7351) as boolean; }
+
+    /**
+     * Returns `true` if the application is in picture-in-picture mode.
+     * **Note:** This method is implemented on Android.
+     */
+    static isInPipMode(windowId?: number /* = 0 */): boolean { return _C($(), 8018, windowId) as boolean; }
+
+    /**
+     * Enters picture-in-picture mode.
+     * **Note:** This method is implemented on Android.
+     */
+    static pipModeEnter(windowId?: number /* = 0 */): void { _C($(), 9431, windowId); }
+
+    /**
+     * Specifies the aspect ratio for picture-in-picture mode.
+     * **Note:** This method is implemented on Android.
+     */
+    static pipModeSetAspectRatio(numerator: number, denominator: number, windowId?: number /* = 0 */): void { _C($(), 9432, numerator, denominator, windowId); }
+
+    /**
+     * Specifies whether picture-in-picture mode should be entered automatically when the application goes in the background.
+     * **Note:** This method is implemented on Android.
+     */
+    static pipModeSetAutoEnterOnBackground(autoEnterOnBackground: boolean, windowId?: number /* = 0 */): void { _C($(), 9433, autoEnterOnBackground, windowId); }
+
+    /**
+     * The ID that refers to a screen that does not exist. This is returned by some {@link DisplayServer} methods if no screen matches the requested result.
+     */
+    static readonly INVALID_SCREEN = -1;
+
+    /**
+     * Represents the screen containing the mouse pointer.
+     * **Note:** On Android, iOS, Web, and Linux (Wayland), this constant always represents the screen at index `0`.
+     */
+    static readonly SCREEN_WITH_MOUSE_FOCUS = -4;
+
+    /**
+     * Represents the screen containing the window with the keyboard focus.
+     * **Note:** On Android, iOS, Web, and Linux (Wayland), this constant always represents the screen at index `0`.
+     */
+    static readonly SCREEN_WITH_KEYBOARD_FOCUS = -3;
+
+    /**
+     * Represents the primary screen.
+     * **Note:** On Android, iOS, Web, and Linux (Wayland), this constant always represents the screen at index `0`.
+     */
+    static readonly SCREEN_PRIMARY = -2;
+
+    /**
+     * Represents the screen where the main window is located. This is usually the default value in functions that allow specifying one of several screens.
+     * **Note:** On Android, iOS, Web, and Linux (Wayland), this constant always represents the screen at index `0`.
+     */
+    static readonly SCREEN_OF_MAIN_WINDOW = -1;
+
+    /**
+     * The ID of the main window spawned by the engine, which can be passed to methods expecting a `window_id`.
+     */
+    static readonly MAIN_WINDOW_ID = 0;
+
+    /**
+     * The ID that refers to a nonexistent window. This is returned by some {@link DisplayServer} methods if no window matches the requested result.
+     */
+    static readonly INVALID_WINDOW_ID = -1;
+
+    /**
+     * The ID that refers to a nonexistent application status indicator.
+     */
+    static readonly INVALID_INDICATOR_ID = -1;
+
+    /**
+     * 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.
+     */
+    static get orientationChanged(): Signal<(orientation: number) => void> { return _G($(), 9216) as Signal<(orientation: number) => void>; }
+    static set orientationChanged(v: ((orientation: number) => void) | null) { _G($(), 9216, v); }
+
+    static readonly name = _R(249, DisplayServer);
+}
+
+export const Feature = {
+    /**
+     * Display server supports global menu. This allows the application to display its menu items in the operating system's top bar. **macOS**
+     */
+    FEATURE_GLOBAL_MENU: 0,
+    /**
+     * Display server supports multiple windows that can be moved outside of the main window. **Windows, macOS, Linux (X11)**
+     */
+    FEATURE_SUBWINDOWS: 1,
+    /**
+     * Display server supports touchscreen input. **Windows, Linux (X11/Wayland), Android, iOS, Web**
+     */
+    FEATURE_TOUCHSCREEN: 2,
+    /**
+     * Display server supports mouse input. **Windows, macOS, Linux (X11/Wayland), Android, Web**
+     */
+    FEATURE_MOUSE: 3,
+    /**
+     * Display server supports warping mouse coordinates to keep the mouse cursor constrained within an area, but looping when one of the edges is reached. **Windows, macOS, Linux (X11/Wayland)**
+     */
+    FEATURE_MOUSE_WARP: 4,
+    /**
+     * Display server supports setting and getting clipboard data. See also {@link FEATURE_CLIPBOARD_PRIMARY}. **Windows, macOS, Linux (X11/Wayland), Android, iOS, Web**
+     */
+    FEATURE_CLIPBOARD: 5,
+    /**
+     * Display server supports popping up a virtual keyboard when requested to input text without a physical keyboard. **Android, iOS, Web**
+     */
+    FEATURE_VIRTUAL_KEYBOARD: 6,
+    /**
+     * Display server supports setting the mouse cursor shape to be different from the default. **Windows, macOS, Linux (X11/Wayland), Android, Web**
+     */
+    FEATURE_CURSOR_SHAPE: 7,
+    /**
+     * Display server supports setting the mouse cursor shape to a custom image. **Windows, macOS, Linux (X11/Wayland), Web**
+     */
+    FEATURE_CUSTOM_CURSOR_SHAPE: 8,
+    /**
+     * Display server supports spawning text dialogs using the operating system's native look-and-feel. See {@link dialogShow}. **Windows, macOS**
+     */
+    FEATURE_NATIVE_DIALOG: 9,
+    /**
+     * Display server supports [Input Method Editor](https://en.wikipedia.org/wiki/Input_method), which is commonly used for inputting Chinese/Japanese/Korean text. This is handled by the operating system, rather than by Godot. **Windows, macOS, Linux (X11)**
+     */
+    FEATURE_IME: 10,
+    /**
+     * Display server supports windows can use per-pixel transparency to make windows behind them partially or fully visible. **Windows, macOS, Linux (X11/Wayland), Android**
+     */
+    FEATURE_WINDOW_TRANSPARENCY: 11,
+    /**
+     * Display server supports querying the operating system's display scale factor. This allows automatically detecting the hiDPI display *reliably*, instead of guessing based on the screen resolution and the display's reported DPI (which might be unreliable due to broken monitor EDID). **Windows, Linux (Wayland), macOS**
+     */
+    FEATURE_HIDPI: 12,
+    /**
+     * Display server supports changing the window icon (usually displayed in the top-left corner). **Windows, macOS, Linux (X11/Wayland)**
+     * **Note:** Use on Wayland requires the compositor to implement the [xdg_toplevel_icon_v1](https://wayland.app/protocols/xdg-toplevel-icon-v1#xdg_toplevel_icon_v1) protocol, which not all compositors do. See [xdg_toplevel_icon_v1#compositor-support](https://wayland.app/protocols/xdg-toplevel-icon-v1#compositor-support) for more information on individual compositor support.
+     */
+    FEATURE_ICON: 13,
+    /**
+     * Display server supports changing the window icon (usually displayed in the top-left corner). **Windows, macOS**
+     */
+    FEATURE_NATIVE_ICON: 14,
+    /**
+     * Display server supports changing the screen orientation. **Android, iOS**
+     */
+    FEATURE_ORIENTATION: 15,
+    /**
+     * Display server supports V-Sync status can be changed from the default (which is forced to be enabled platforms not supporting this feature). **Windows, macOS, Linux (X11/Wayland)**
+     */
+    FEATURE_SWAP_BUFFERS: 16,
+    /**
+     * Display server supports Primary clipboard can be used. This is a different clipboard from {@link FEATURE_CLIPBOARD}. **Linux (X11/Wayland)**
+     */
+    FEATURE_CLIPBOARD_PRIMARY: 18,
+    /**
+     * Display server supports text-to-speech. See `tts_*` methods. **Windows, macOS, Linux (X11/Wayland), Android, iOS, Web**
+     */
+    FEATURE_TEXT_TO_SPEECH: 19,
+    /**
+     * Display server supports expanding window content to the title. See {@link WINDOW_FLAG_EXTEND_TO_TITLE}. **macOS**
+     */
+    FEATURE_EXTEND_TO_TITLE: 20,
+    /**
+     * Display server supports reading screen pixels. See {@link screenGetPixel}.
+     */
+    FEATURE_SCREEN_CAPTURE: 21,
+    /**
+     * Display server supports application status indicators.
+     */
+    FEATURE_STATUS_INDICATOR: 22,
+    /**
+     * Display server supports native help system search callbacks. See {@link helpSetSearchCallbacks}.
+     */
+    FEATURE_NATIVE_HELP: 23,
+    /**
+     * Display server supports spawning text input dialogs using the operating system's native look-and-feel. See {@link dialogInputText}. **Windows, macOS**
+     */
+    FEATURE_NATIVE_DIALOG_INPUT: 24,
+    /**
+     * Display server supports spawning dialogs for selecting files or directories using the operating system's native look-and-feel. See {@link fileDialogShow}. **Windows, macOS, Linux (X11/Wayland), Android**
+     */
+    FEATURE_NATIVE_DIALOG_FILE: 25,
+    /**
+     * The display server supports all features of {@link FEATURE_NATIVE_DIALOG_FILE}, with the added functionality of Options and native dialog file access to `res://` and `user://` paths. See {@link fileDialogShow} and {@link fileDialogWithOptionsShow}. **Windows, macOS, Linux (X11/Wayland)**
+     */
+    FEATURE_NATIVE_DIALOG_FILE_EXTRA: 26,
+    /**
+     * The display server supports initiating window drag and resize operations on demand. See {@link windowStartDrag} and {@link windowStartResize}.
+     */
+    FEATURE_WINDOW_DRAG: 27,
+    /**
+     * Display server supports {@link WINDOW_FLAG_EXCLUDE_FROM_CAPTURE} window flag. **Windows, macOS**
+     */
+    FEATURE_SCREEN_EXCLUDE_FROM_CAPTURE: 28,
+    /**
+     * Display server supports embedding a window from another process. **Windows, Linux (X11), macOS**
+     */
+    FEATURE_WINDOW_EMBEDDING: 29,
+    /**
+     * Native file selection dialog supports MIME types as filters.
+     */
+    FEATURE_NATIVE_DIALOG_FILE_MIME: 30,
+    /**
+     * Display server supports system emoji and symbol picker. **Windows, macOS**
+     */
+    FEATURE_EMOJI_AND_SYMBOL_PICKER: 31,
+    /**
+     * Display server supports native color picker. **Linux (X11/Wayland)**
+     */
+    FEATURE_NATIVE_COLOR_PICKER: 32,
+    /**
+     * Display server automatically fits popups according to the screen boundaries. Window nodes should not attempt to do that themselves.
+     */
+    FEATURE_SELF_FITTING_WINDOWS: 33,
+    /**
+     * Display server supports interaction with screen reader or Braille display. **Linux (X11/Wayland), macOS, Windows**
+     */
+    FEATURE_ACCESSIBILITY_SCREEN_READER: 34,
+    /**
+     * Display server supports HDR output. **Linux (Wayland), macOS, iOS, visionOS, Windows**
+     */
+    FEATURE_HDR_OUTPUT: 35,
+    /**
+     * Display server supports putting the application in picture-in-picture mode. **Android**
+     */
+    FEATURE_PIP_MODE: 36,
+} as const;
+
+export type Feature = (typeof Feature)[keyof typeof Feature];
+
+export const AccessibilityRole = {
+    /**
+     * Unknown or custom role.
+     */
+    ROLE_UNKNOWN: 0,
+    /**
+     * Default dialog button element.
+     */
+    ROLE_DEFAULT_BUTTON: 1,
+    /**
+     * Audio player element.
+     */
+    ROLE_AUDIO: 2,
+    /**
+     * Video player element.
+     */
+    ROLE_VIDEO: 3,
+    /**
+     * Non-editable text label.
+     */
+    ROLE_STATIC_TEXT: 4,
+    /**
+     * Container element. Elements with this role are used for internal structure and ignored by screen readers.
+     */
+    ROLE_CONTAINER: 5,
+    /**
+     * Panel container element.
+     */
+    ROLE_PANEL: 6,
+    /**
+     * Button element.
+     */
+    ROLE_BUTTON: 7,
+    /**
+     * Link element.
+     */
+    ROLE_LINK: 8,
+    /**
+     * Check box element.
+     */
+    ROLE_CHECK_BOX: 9,
+    /**
+     * Radio button element.
+     */
+    ROLE_RADIO_BUTTON: 10,
+    /**
+     * Check button element.
+     */
+    ROLE_CHECK_BUTTON: 11,
+    /**
+     * Scroll bar element.
+     */
+    ROLE_SCROLL_BAR: 12,
+    /**
+     * Scroll container element.
+     */
+    ROLE_SCROLL_VIEW: 13,
+    /**
+     * Container splitter handle element.
+     */
+    ROLE_SPLITTER: 14,
+    /**
+     * Slider element.
+     */
+    ROLE_SLIDER: 15,
+    /**
+     * Spin box element.
+     */
+    ROLE_SPIN_BUTTON: 16,
+    /**
+     * Progress indicator element.
+     */
+    ROLE_PROGRESS_INDICATOR: 17,
+    /**
+     * Editable text field element.
+     */
+    ROLE_TEXT_FIELD: 18,
+    /**
+     * Multiline editable text field element.
+     */
+    ROLE_MULTILINE_TEXT_FIELD: 19,
+    /**
+     * Color picker element.
+     */
+    ROLE_COLOR_PICKER: 20,
+    /**
+     * Table element.
+     */
+    ROLE_TABLE: 21,
+    /**
+     * Table/tree cell element.
+     */
+    ROLE_CELL: 22,
+    /**
+     * Table/tree row element.
+     */
+    ROLE_ROW: 23,
+    /**
+     * Table/tree row group element.
+     */
+    ROLE_ROW_GROUP: 24,
+    /**
+     * Table/tree row header element.
+     */
+    ROLE_ROW_HEADER: 25,
+    /**
+     * Table/tree column header element.
+     */
+    ROLE_COLUMN_HEADER: 26,
+    /**
+     * Tree view element.
+     */
+    ROLE_TREE: 27,
+    /**
+     * Tree view item element.
+     */
+    ROLE_TREE_ITEM: 28,
+    /**
+     * List element.
+     */
+    ROLE_LIST: 29,
+    /**
+     * List item element.
+     */
+    ROLE_LIST_ITEM: 30,
+    /**
+     * List view element.
+     */
+    ROLE_LIST_BOX: 31,
+    /**
+     * List view item element.
+     */
+    ROLE_LIST_BOX_OPTION: 32,
+    /**
+     * Tab bar element.
+     */
+    ROLE_TAB_BAR: 33,
+    /**
+     * Tab bar item element.
+     */
+    ROLE_TAB: 34,
+    /**
+     * Tab panel element.
+     */
+    ROLE_TAB_PANEL: 35,
+    /**
+     * Menu bar element.
+     */
+    ROLE_MENU_BAR: 36,
+    /**
+     * Popup menu element.
+     */
+    ROLE_MENU: 37,
+    /**
+     * Popup menu item element.
+     */
+    ROLE_MENU_ITEM: 38,
+    /**
+     * Popup menu check button item element.
+     */
+    ROLE_MENU_ITEM_CHECK_BOX: 39,
+    /**
+     * Popup menu radio button item element.
+     */
+    ROLE_MENU_ITEM_RADIO: 40,
+    /**
+     * Image element.
+     */
+    ROLE_IMAGE: 41,
+    /**
+     * Window element.
+     */
+    ROLE_WINDOW: 42,
+    /**
+     * Embedded window title bar element.
+     */
+    ROLE_TITLE_BAR: 43,
+    /**
+     * Dialog window element.
+     */
+    ROLE_DIALOG: 44,
+    /**
+     * Tooltip element.
+     */
+    ROLE_TOOLTIP: 45,
+    /**
+     * Region/landmark element. Screen readers can navigate between regions using landmark navigation.
+     */
+    ROLE_REGION: 46,
+    /**
+     * Unifor text run.
+     * Note: This role is used for internal text elements, and should not be assigned to nodes.
+     */
+    ROLE_TEXT_RUN: 47,
+} as const;
+
+export type AccessibilityRole = (typeof AccessibilityRole)[keyof typeof AccessibilityRole];
+
+export const AccessibilityPopupType = {
+    /**
+     * Popup menu.
+     */
+    POPUP_MENU: 0,
+    /**
+     * Popup list.
+     */
+    POPUP_LIST: 1,
+    /**
+     * Popup tree view.
+     */
+    POPUP_TREE: 2,
+    /**
+     * Popup dialog.
+     */
+    POPUP_DIALOG: 3,
+} as const;
+
+export type AccessibilityPopupType = (typeof AccessibilityPopupType)[keyof typeof AccessibilityPopupType];
+
+export const AccessibilityFlags = {
+    /**
+     * Element is hidden for accessibility tools.
+     */
+    FLAG_HIDDEN: 0,
+    /**
+     * Element supports multiple item selection.
+     */
+    FLAG_MULTISELECTABLE: 1,
+    /**
+     * Element require user input.
+     */
+    FLAG_REQUIRED: 2,
+    /**
+     * Element is a visited link.
+     */
+    FLAG_VISITED: 3,
+    /**
+     * Element content is not ready (e.g. loading).
+     */
+    FLAG_BUSY: 4,
+    /**
+     * Element is modal window.
+     */
+    FLAG_MODAL: 5,
+    /**
+     * Element allows touches to be passed through when a screen reader is in touch exploration mode.
+     */
+    FLAG_TOUCH_PASSTHROUGH: 6,
+    /**
+     * Element is text field with selectable but read-only text.
+     */
+    FLAG_READONLY: 7,
+    /**
+     * Element is disabled.
+     */
+    FLAG_DISABLED: 8,
+    /**
+     * Element clips children.
+     */
+    FLAG_CLIPS_CHILDREN: 9,
+} as const;
+
+export type AccessibilityFlags = (typeof AccessibilityFlags)[keyof typeof AccessibilityFlags];
+
+export const AccessibilityAction = {
+    /**
+     * Single click action, callback argument is not set.
+     */
+    ACTION_CLICK: 0,
+    /**
+     * Focus action, callback argument is not set.
+     */
+    ACTION_FOCUS: 1,
+    /**
+     * Blur action, callback argument is not set.
+     */
+    ACTION_BLUR: 2,
+    /**
+     * Collapse action, callback argument is not set.
+     */
+    ACTION_COLLAPSE: 3,
+    /**
+     * Expand action, callback argument is not set.
+     */
+    ACTION_EXPAND: 4,
+    /**
+     * Decrement action, callback argument is not set.
+     */
+    ACTION_DECREMENT: 5,
+    /**
+     * Increment action, callback argument is not set.
+     */
+    ACTION_INCREMENT: 6,
+    /**
+     * Hide tooltip action, callback argument is not set.
+     */
+    ACTION_HIDE_TOOLTIP: 7,
+    /**
+     * Show tooltip action, callback argument is not set.
+     */
+    ACTION_SHOW_TOOLTIP: 8,
+    /**
+     * Set text selection action, callback argument is set to {@link Dictionary} with the following keys:
+     * - `"start_element"` accessibility element of the selection start.
+     * - `"start_char"` character offset relative to the accessibility element of the selection start.
+     * - `"end_element"` accessibility element of the selection end.
+     * - `"end_char"` character offset relative to the accessibility element of the selection end.
+     */
+    ACTION_SET_TEXT_SELECTION: 9,
+    /**
+     * Replace text action, callback argument is set to {@link String} with the replacement text.
+     */
+    ACTION_REPLACE_SELECTED_TEXT: 10,
+    /**
+     * Scroll backward action, callback argument is not set.
+     */
+    ACTION_SCROLL_BACKWARD: 11,
+    /**
+     * Scroll down action, callback argument is set to {@link AccessibilityScrollUnit}.
+     */
+    ACTION_SCROLL_DOWN: 12,
+    /**
+     * Scroll forward action, callback argument is not set.
+     */
+    ACTION_SCROLL_FORWARD: 13,
+    /**
+     * Scroll left action, callback argument is set to {@link AccessibilityScrollUnit}.
+     */
+    ACTION_SCROLL_LEFT: 14,
+    /**
+     * Scroll right action, callback argument is set to {@link AccessibilityScrollUnit}.
+     */
+    ACTION_SCROLL_RIGHT: 15,
+    /**
+     * Scroll up action, callback argument is set to {@link AccessibilityScrollUnit}.
+     */
+    ACTION_SCROLL_UP: 16,
+    /**
+     * Scroll into view action, callback argument is set to {@link AccessibilityScrollHint}.
+     */
+    ACTION_SCROLL_INTO_VIEW: 17,
+    /**
+     * Scroll to point action, callback argument is set to {@link Vector2} with the relative point coordinates.
+     */
+    ACTION_SCROLL_TO_POINT: 18,
+    /**
+     * Set scroll offset action, callback argument is set to {@link Vector2} with the scroll offset.
+     */
+    ACTION_SET_SCROLL_OFFSET: 19,
+    /**
+     * Set value action, callback argument is set to {@link String} or number with the new value.
+     */
+    ACTION_SET_VALUE: 20,
+    /**
+     * Show context menu action, callback argument is not set.
+     */
+    ACTION_SHOW_CONTEXT_MENU: 21,
+    /**
+     * Custom action, callback argument is set to the integer action ID.
+     */
+    ACTION_CUSTOM: 22,
+} as const;
+
+export type AccessibilityAction = (typeof AccessibilityAction)[keyof typeof AccessibilityAction];
+
+export const AccessibilityLiveMode = {
+    /**
+     * Indicates that updates to the live region should not be presented.
+     */
+    LIVE_OFF: 0,
+    /**
+     * Indicates that updates to the live region should be presented at the next opportunity (for example at the end of speaking the current sentence).
+     */
+    LIVE_POLITE: 1,
+    /**
+     * Indicates that updates to the live region have the highest priority and should be presented immediately.
+     */
+    LIVE_ASSERTIVE: 2,
+} as const;
+
+export type AccessibilityLiveMode = (typeof AccessibilityLiveMode)[keyof typeof AccessibilityLiveMode];
+
+export const AccessibilityScrollUnit = {
+    /**
+     * The amount by which to scroll. A single item of a list, line of text.
+     */
+    SCROLL_UNIT_ITEM: 0,
+    /**
+     * The amount by which to scroll. A single page.
+     */
+    SCROLL_UNIT_PAGE: 1,
+} as const;
+
+export type AccessibilityScrollUnit = (typeof AccessibilityScrollUnit)[keyof typeof AccessibilityScrollUnit];
+
+export const AccessibilityScrollHint = {
+    /**
+     * A preferred position for the node scrolled into view. Top-left edge of the scroll container.
+     */
+    SCROLL_HINT_TOP_LEFT: 0,
+    /**
+     * A preferred position for the node scrolled into view. Bottom-right edge of the scroll container.
+     */
+    SCROLL_HINT_BOTTOM_RIGHT: 1,
+    /**
+     * A preferred position for the node scrolled into view. Top edge of the scroll container.
+     */
+    SCROLL_HINT_TOP_EDGE: 2,
+    /**
+     * A preferred position for the node scrolled into view. Bottom edge of the scroll container.
+     */
+    SCROLL_HINT_BOTTOM_EDGE: 3,
+    /**
+     * A preferred position for the node scrolled into view. Left edge of the scroll container.
+     */
+    SCROLL_HINT_LEFT_EDGE: 4,
+    /**
+     * A preferred position for the node scrolled into view. Right edge of the scroll container.
+     */
+    SCROLL_HINT_RIGHT_EDGE: 5,
+} as const;
+
+export type AccessibilityScrollHint = (typeof AccessibilityScrollHint)[keyof typeof AccessibilityScrollHint];
+
+export const MouseMode = {
+    /**
+     * Makes the mouse cursor visible if it is hidden.
+     */
+    MOUSE_MODE_VISIBLE: 0,
+    /**
+     * Makes the mouse cursor hidden if it is visible.
+     */
+    MOUSE_MODE_HIDDEN: 1,
+    /**
+     * Captures the mouse. The mouse will be hidden and its position locked at the center of the window manager's window.
+     * **Note:** If you want to process the mouse's movement in this mode, you need to use {@link InputEventMouseMotion.relative}.
+     */
+    MOUSE_MODE_CAPTURED: 2,
+    /**
+     * Confines the mouse cursor to the game window, and make it visible.
+     */
+    MOUSE_MODE_CONFINED: 3,
+    /**
+     * Confines the mouse cursor to the game window, and make it hidden.
+     */
+    MOUSE_MODE_CONFINED_HIDDEN: 4,
+    /**
+     * Max value of the {@link MouseMode}.
+     */
+    MOUSE_MODE_MAX: 5,
+} as const;
+
+export type MouseMode = (typeof MouseMode)[keyof typeof MouseMode];
+
+export const ScreenOrientation = {
+    /**
+     * Default landscape orientation.
+     */
+    SCREEN_LANDSCAPE: 0,
+    /**
+     * Default portrait orientation.
+     */
+    SCREEN_PORTRAIT: 1,
+    /**
+     * Reverse landscape orientation (upside down).
+     */
+    SCREEN_REVERSE_LANDSCAPE: 2,
+    /**
+     * Reverse portrait orientation (upside down).
+     */
+    SCREEN_REVERSE_PORTRAIT: 3,
+    /**
+     * Automatic landscape orientation (default or reverse depending on sensor).
+     */
+    SCREEN_SENSOR_LANDSCAPE: 4,
+    /**
+     * Automatic portrait orientation (default or reverse depending on sensor).
+     */
+    SCREEN_SENSOR_PORTRAIT: 5,
+    /**
+     * Automatic landscape or portrait orientation (default or reverse depending on sensor).
+     */
+    SCREEN_SENSOR: 6,
+} as const;
+
+export type ScreenOrientation = (typeof ScreenOrientation)[keyof typeof ScreenOrientation];
+
+export const VirtualKeyboardType = {
+    /**
+     * Default text virtual keyboard.
+     */
+    KEYBOARD_TYPE_DEFAULT: 0,
+    /**
+     * Multiline virtual keyboard.
+     */
+    KEYBOARD_TYPE_MULTILINE: 1,
+    /**
+     * Virtual number keypad, useful for PIN entry.
+     */
+    KEYBOARD_TYPE_NUMBER: 2,
+    /**
+     * Virtual number keypad, useful for entering fractional numbers.
+     */
+    KEYBOARD_TYPE_NUMBER_DECIMAL: 3,
+    /**
+     * Virtual phone number keypad.
+     */
+    KEYBOARD_TYPE_PHONE: 4,
+    /**
+     * Virtual keyboard with additional keys to assist with typing email addresses.
+     */
+    KEYBOARD_TYPE_EMAIL_ADDRESS: 5,
+    /**
+     * Virtual keyboard for entering a password. On most platforms, this should disable autocomplete and autocapitalization.
+     * **Note:** This is not supported on Web. Instead, this behaves identically to {@link KEYBOARD_TYPE_DEFAULT}.
+     */
+    KEYBOARD_TYPE_PASSWORD: 6,
+    /**
+     * Virtual keyboard with additional keys to assist with typing URLs.
+     */
+    KEYBOARD_TYPE_URL: 7,
+} as const;
+
+export type VirtualKeyboardType = (typeof VirtualKeyboardType)[keyof typeof VirtualKeyboardType];
+
+export const CursorShape = {
+    /**
+     * Arrow cursor shape. This is the default when not pointing anything that overrides the mouse cursor, such as a {@link LineEdit} or {@link TextEdit}.
+     */
+    CURSOR_ARROW: 0,
+    /**
+     * I-beam cursor shape. This is used by default when hovering a control that accepts text input, such as {@link LineEdit} or {@link TextEdit}.
+     */
+    CURSOR_IBEAM: 1,
+    /**
+     * Pointing hand cursor shape. This is used by default when hovering a {@link LinkButton} or a URL tag in a {@link RichTextLabel}.
+     */
+    CURSOR_POINTING_HAND: 2,
+    /**
+     * Crosshair cursor. This is intended to be displayed when the user needs precise aim over an element, such as a rectangle selection tool or a color picker.
+     */
+    CURSOR_CROSS: 3,
+    /**
+     * Wait cursor. On most cursor themes, this displays a spinning icon *besides* the arrow. Intended to be used for non-blocking operations (when the user can do something else at the moment). See also {@link CURSOR_BUSY}.
+     */
+    CURSOR_WAIT: 4,
+    /**
+     * Wait cursor. On most cursor themes, this *replaces* the arrow with a spinning icon. Intended to be used for blocking operations (when the user can't do anything else at the moment). See also {@link CURSOR_WAIT}.
+     */
+    CURSOR_BUSY: 5,
+    /**
+     * Dragging hand cursor. This is displayed during drag-and-drop operations. See also {@link CURSOR_CAN_DROP}.
+     */
+    CURSOR_DRAG: 6,
+    /**
+     * "Can drop" cursor. This is displayed during drag-and-drop operations if hovering over a {@link Control} that can accept the drag-and-drop event. On most cursor themes, this displays a dragging hand with an arrow symbol besides it. See also {@link CURSOR_DRAG}.
+     */
+    CURSOR_CAN_DROP: 7,
+    /**
+     * Forbidden cursor. This is displayed during drag-and-drop operations if the hovered {@link Control} can't accept the drag-and-drop event.
+     */
+    CURSOR_FORBIDDEN: 8,
+    /**
+     * Vertical resize cursor. Intended to be displayed when the hovered {@link Control} can be vertically resized using the mouse. See also {@link CURSOR_VSPLIT}.
+     */
+    CURSOR_VSIZE: 9,
+    /**
+     * Horizontal resize cursor. Intended to be displayed when the hovered {@link Control} can be horizontally resized using the mouse. See also {@link CURSOR_HSPLIT}.
+     */
+    CURSOR_HSIZE: 10,
+    /**
+     * Secondary diagonal resize cursor (top-right/bottom-left). Intended to be displayed when the hovered {@link Control} can be resized on both axes at once using the mouse.
+     */
+    CURSOR_BDIAGSIZE: 11,
+    /**
+     * Main diagonal resize cursor (top-left/bottom-right). Intended to be displayed when the hovered {@link Control} can be resized on both axes at once using the mouse.
+     */
+    CURSOR_FDIAGSIZE: 12,
+    /**
+     * Move cursor. Intended to be displayed when the hovered {@link Control} can be moved using the mouse.
+     */
+    CURSOR_MOVE: 13,
+    /**
+     * Vertical split cursor. This is displayed when hovering a {@link Control} with splits that can be vertically resized using the mouse, such as {@link VSplitContainer}. On some cursor themes, this cursor may have the same appearance as {@link CURSOR_VSIZE}.
+     */
+    CURSOR_VSPLIT: 14,
+    /**
+     * Horizontal split cursor. This is displayed when hovering a {@link Control} with splits that can be horizontally resized using the mouse, such as {@link HSplitContainer}. On some cursor themes, this cursor may have the same appearance as {@link CURSOR_HSIZE}.
+     */
+    CURSOR_HSPLIT: 15,
+    /**
+     * Help cursor. On most cursor themes, this displays a question mark icon instead of the mouse cursor. Intended to be used when the user has requested help on the next element that will be clicked.
+     */
+    CURSOR_HELP: 16,
+    /**
+     * Represents the size of the {@link CursorShape} enum.
+     */
+    CURSOR_MAX: 17,
+} as const;
+
+export type CursorShape = (typeof CursorShape)[keyof typeof CursorShape];
+
+export const FileDialogMode = {
+    /**
+     * The native file dialog allows selecting one, and only one file.
+     */
+    FILE_DIALOG_MODE_OPEN_FILE: 0,
+    /**
+     * The native file dialog allows selecting multiple files.
+     */
+    FILE_DIALOG_MODE_OPEN_FILES: 1,
+    /**
+     * The native file dialog only allows selecting a directory, disallowing the selection of any file.
+     */
+    FILE_DIALOG_MODE_OPEN_DIR: 2,
+    /**
+     * The native file dialog allows selecting one file or directory.
+     */
+    FILE_DIALOG_MODE_OPEN_ANY: 3,
+    /**
+     * The native file dialog will warn when a file exists.
+     */
+    FILE_DIALOG_MODE_SAVE_FILE: 4,
+} as const;
+
+export type FileDialogMode = (typeof FileDialogMode)[keyof typeof FileDialogMode];
+
+export const WindowMode = {
+    /**
+     * Windowed mode, i.e. {@link Window} doesn't occupy the whole screen (unless set to the size of the screen).
+     */
+    WINDOW_MODE_WINDOWED: 0,
+    /**
+     * Minimized window mode, i.e. {@link Window} is not visible and available on window manager's window list. Normally happens when the minimize button is pressed.
+     */
+    WINDOW_MODE_MINIMIZED: 1,
+    /**
+     * Maximized window mode, i.e. {@link Window} will occupy whole screen area except task bar and still display its borders. Normally happens when the maximize button is pressed.
+     */
+    WINDOW_MODE_MAXIMIZED: 2,
+    /**
+     * Full screen mode with full multi-window support.
+     * Full screen window covers the entire display area of a screen and has no decorations. The display's video mode is not changed.
+     * **On Android:** This enables immersive mode.
+     * **On macOS:** A new desktop is used to display the running project.
+     * **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.
+     */
+    WINDOW_MODE_FULLSCREEN: 3,
+    /**
+     * A single window full screen mode. This mode has less overhead, but only one window can be open on a given screen at a time (opening a child window or application switching will trigger a full screen transition).
+     * Full screen window covers the entire display area of a screen and has no border or decorations. The display's video mode is not changed.
+     * **Note:** This mode might not work with screen recording software.
+     * **On Android:** This enables immersive mode.
+     * **On Windows:** Depending on video driver, full screen transition might cause screens to go black for a moment.
+     * **On macOS:** A new desktop is used to display the running project. Exclusive full screen mode prevents Dock and Menu from showing up when the mouse pointer is hovering the edge of the screen.
+     * **On Linux (X11):** Exclusive full screen mode bypasses compositor.
+     * **On Linux (Wayland):** Equivalent to {@link WINDOW_MODE_FULLSCREEN}.
+     * **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.
+     */
+    WINDOW_MODE_EXCLUSIVE_FULLSCREEN: 4,
+} as const;
+
+export type WindowMode = (typeof WindowMode)[keyof typeof WindowMode];
+
+export const ProgressState = {
+    /**
+     * Stops displaying progress and returns the button to its normal state.
+     */
+    PROGRESS_STATE_NOPROGRESS: 0,
+    /**
+     * 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.
+     */
+    PROGRESS_STATE_INDETERMINATE: 1,
+    /**
+     * The progress indicator shows progress normally.
+     */
+    PROGRESS_STATE_NORMAL: 2,
+    /**
+     * 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.
+     */
+    PROGRESS_STATE_ERROR: 3,
+    /**
+     * 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.
+     */
+    PROGRESS_STATE_PAUSED: 4,
+} as const;
+
+export type ProgressState = (typeof ProgressState)[keyof typeof ProgressState];
+
+export const WindowFlags = {
+    /**
+     * The window can't be resized by dragging its resize grip. It's still possible to resize the window using {@link windowSetSize}. This flag is ignored for full screen windows.
+     * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+     */
+    WINDOW_FLAG_RESIZE_DISABLED: 0,
+    /**
+     * 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.
+     */
+    WINDOW_FLAG_BORDERLESS: 1,
+    /**
+     * 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.
+     */
+    WINDOW_FLAG_ALWAYS_ON_TOP: 2,
+    /**
+     * The window background can be transparent.
+     * **Note:** This flag has no effect if {@link isWindowTransparencyAvailable} returns `false`.
+     * **Note:** Transparency support is implemented on Linux (X11/Wayland), macOS, and Windows, but availability might vary depending on GPU driver, display manager, and compositor capabilities.
+     * **Note:** Transparency support is implemented on Android, but can only be enabled via {@link ProjectSettings.display/window/perPixelTransparency/allowed}. This flag has no effect on Android.
+     */
+    WINDOW_FLAG_TRANSPARENT: 3,
+    /**
+     * 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.
+     */
+    WINDOW_FLAG_NO_FOCUS: 4,
+    /**
+     * 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 windowSetTransient}).
+     * **Note:** This flag is implemented on Linux (X11/Wayland), macOS, and Windows.
+     */
+    WINDOW_FLAG_POPUP: 5,
+    /**
+     * Window content is expanded to the full size of the window. Unlike borderless window, the frame is left intact and can be used to resize the window, title bar is transparent, but have minimize/maximize/close buttons.
+     * Use {@link windowSetWindowButtonsOffset} to adjust minimize/maximize/close buttons offset.
+     * Use {@link windowGetSafeTitleMargins} to determine area under the title bar that is not covered by decorations.
+     * **Note:** This flag is implemented only on macOS.
+     */
+    WINDOW_FLAG_EXTEND_TO_TITLE: 6,
+    /**
+     * All mouse events are passed to the underlying window of the same application.
+     * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+     */
+    WINDOW_FLAG_MOUSE_PASSTHROUGH: 7,
+    /**
+     * Window style is overridden, forcing sharp corners.
+     * **Note:** This flag is implemented only on Windows (11).
+     */
+    WINDOW_FLAG_SHARP_CORNERS: 8,
+    /**
+     * Window is excluded from screenshots taken by {@link screenGetImage}, {@link screenGetImageRect}, and {@link screenGetPixel}.
+     * **Note:** This flag is implemented on macOS and Windows (10, 20H1).
+     * **Note:** Setting this flag will prevent standard screenshot methods from capturing a window image, but does **NOT** guarantee that other apps won't be able to capture an image. It should not be used as a DRM or security measure.
+     */
+    WINDOW_FLAG_EXCLUDE_FROM_CAPTURE: 9,
+    /**
+     * 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).
+     */
+    WINDOW_FLAG_POPUP_WM_HINT: 10,
+    /**
+     * Window minimize button is disabled.
+     * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+     */
+    WINDOW_FLAG_MINIMIZE_DISABLED: 11,
+    /**
+     * Window maximize button is disabled.
+     * **Note:** This flag is implemented on Linux (X11), macOS, and Windows.
+     */
+    WINDOW_FLAG_MAXIMIZE_DISABLED: 12,
+    /**
+     * Represents the size of the {@link WindowFlags} enum.
+     */
+    WINDOW_FLAG_MAX: 13,
+} as const;
+
+export type WindowFlags = (typeof WindowFlags)[keyof typeof WindowFlags];
+
+export const WindowEvent = {
+    /**
+     * Sent when the mouse pointer enters the window.
+     */
+    WINDOW_EVENT_MOUSE_ENTER: 0,
+    /**
+     * Sent when the mouse pointer exits the window.
+     */
+    WINDOW_EVENT_MOUSE_EXIT: 1,
+    /**
+     * Sent when the window grabs focus.
+     */
+    WINDOW_EVENT_FOCUS_IN: 2,
+    /**
+     * Sent when the window loses focus.
+     */
+    WINDOW_EVENT_FOCUS_OUT: 3,
+    /**
+     * Sent when the user has attempted to close the window (e.g. close button is pressed).
+     */
+    WINDOW_EVENT_CLOSE_REQUEST: 4,
+    /**
+     * Sent when the device "Back" button is pressed.
+     * **Note:** This event is implemented only on Android.
+     */
+    WINDOW_EVENT_GO_BACK_REQUEST: 5,
+    /**
+     * Sent when the window is moved to the display with different DPI, or display DPI is changed.
+     * **Note:** This flag is implemented only on macOS and Linux (Wayland).
+     */
+    WINDOW_EVENT_DPI_CHANGE: 6,
+    /**
+     * Sent when the window title bar decoration is changed (e.g. {@link WINDOW_FLAG_EXTEND_TO_TITLE} is set or window entered/exited full screen mode).
+     * **Note:** This flag is implemented only on macOS.
+     */
+    WINDOW_EVENT_TITLEBAR_CHANGE: 7,
+    /**
+     * Sent when the window has been forcibly closed by the display server. The window will immediately hide and clean any internal rendering references.
+     * **Note:** This flag is implemented only on Linux (Wayland).
+     */
+    WINDOW_EVENT_FORCE_CLOSE: 8,
+    /**
+     * Sent when the output max linear value returned by {@link Window.getOutputMaxLinearValue} 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.
+     */
+    WINDOW_EVENT_OUTPUT_MAX_LINEAR_VALUE_CHANGED: 9,
+} as const;
+
+export type WindowEvent = (typeof WindowEvent)[keyof typeof WindowEvent];
+
+export const WindowResizeEdge = {
+    /**
+     * Top-left edge of a window.
+     */
+    WINDOW_EDGE_TOP_LEFT: 0,
+    /**
+     * Top edge of a window.
+     */
+    WINDOW_EDGE_TOP: 1,
+    /**
+     * Top-right edge of a window.
+     */
+    WINDOW_EDGE_TOP_RIGHT: 2,
+    /**
+     * Left edge of a window.
+     */
+    WINDOW_EDGE_LEFT: 3,
+    /**
+     * Right edge of a window.
+     */
+    WINDOW_EDGE_RIGHT: 4,
+    /**
+     * Bottom-left edge of a window.
+     */
+    WINDOW_EDGE_BOTTOM_LEFT: 5,
+    /**
+     * Bottom edge of a window.
+     */
+    WINDOW_EDGE_BOTTOM: 6,
+    /**
+     * Bottom-right edge of a window.
+     */
+    WINDOW_EDGE_BOTTOM_RIGHT: 7,
+    /**
+     * Represents the size of the {@link WindowResizeEdge} enum.
+     */
+    WINDOW_EDGE_MAX: 8,
+} as const;
+
+export type WindowResizeEdge = (typeof WindowResizeEdge)[keyof typeof WindowResizeEdge];
+
+export const VSyncMode = {
+    /**
+     * No vertical synchronization, which means the engine will display frames as fast as possible (tearing may be visible). Framerate is unlimited (regardless of {@link Engine.maxFps}).
+     */
+    VSYNC_DISABLED: 0,
+    /**
+     * Default vertical synchronization mode, the image is displayed only on vertical blanking intervals (no tearing is visible). Framerate is limited by the monitor refresh rate (regardless of {@link Engine.maxFps}).
+     */
+    VSYNC_ENABLED: 1,
+    /**
+     * Behaves like {@link VSYNC_DISABLED} when the framerate drops below the screen's refresh rate to reduce stuttering (tearing may be visible). Otherwise, vertical synchronization is enabled to avoid tearing. Framerate is limited by the monitor refresh rate (regardless of {@link Engine.maxFps}). Behaves like {@link VSYNC_ENABLED} when using the Compatibility rendering method.
+     */
+    VSYNC_ADAPTIVE: 2,
+    /**
+     * Displays the most recent image in the queue on vertical blanking intervals, while rendering to the other images (no tearing is visible). Framerate is unlimited (regardless of {@link Engine.maxFps}).
+     * Although not guaranteed, the images can be rendered as fast as possible, which may reduce input lag (also called "Fast" V-Sync mode). {@link VSYNC_MAILBOX} works best when at least twice as many frames as the display refresh rate are rendered. Behaves like {@link VSYNC_ENABLED} when using the Compatibility rendering method.
+     */
+    VSYNC_MAILBOX: 3,
+} as const;
+
+export type VSyncMode = (typeof VSyncMode)[keyof typeof VSyncMode];
+
+export const HandleType = {
+    /**
+     * Display handle:
+     * - Linux (X11): `X11::Display*` for the display.
+     * - Linux (Wayland): `wl_display` for the display.
+     * - Android: `EGLDisplay` for the display.
+     */
+    DISPLAY_HANDLE: 0,
+    /**
+     * Window handle:
+     * - Windows: `HWND` for the window.
+     * - Linux (X11): `X11::Window*` for the window.
+     * - Linux (Wayland): `wl_surface` for the window.
+     * - macOS: `NSWindow*` for the window.
+     * - iOS: `UIViewController*` for the view controller.
+     * - Android: `jObject` for the activity.
+     */
+    WINDOW_HANDLE: 1,
+    /**
+     * Window view:
+     * - Windows: `HDC` for the window (only with the Compatibility renderer).
+     * - macOS: `NSView*` for the window main view.
+     * - iOS: `UIView*` for the window main view.
+     */
+    WINDOW_VIEW: 2,
+    /**
+     * OpenGL context (only with the Compatibility renderer):
+     * - Windows: `HGLRC` for the window (native GL), or `EGLContext` for the window (ANGLE).
+     * - Linux (X11): `GLXContext*` for the window.
+     * - Linux (Wayland): `EGLContext` for the window.
+     * - macOS: `NSOpenGLContext*` for the window (native GL), or `EGLContext` for the window (ANGLE).
+     * - Android: `EGLContext` for the window.
+     */
+    OPENGL_CONTEXT: 3,
+    /**
+     * - Windows: `EGLDisplay` for the window (ANGLE).
+     * - macOS: `EGLDisplay` for the window (ANGLE).
+     * - Linux (Wayland): `EGLDisplay` for the window.
+     */
+    EGL_DISPLAY: 4,
+    /**
+     * - Windows: `EGLConfig` for the window (ANGLE).
+     * - macOS: `EGLConfig` for the window (ANGLE).
+     * - Linux (Wayland): `EGLConfig` for the window.
+     */
+    EGL_CONFIG: 5,
+    /**
+     * The GLX `VisualID` for the window.
+     * **Note:** Only available on Linux when using X11.
+     */
+    GLX_VISUALID: 6,
+    /**
+     * The `GLXFBConfig` for the window.
+     * **Note:** Only available on Linux when using X11.
+     */
+    GLX_FBCONFIG: 7,
+} as const;
+
+export type HandleType = (typeof HandleType)[keyof typeof HandleType];
+
+export const TTSUtteranceEvent = {
+    /**
+     * Utterance has begun to be spoken.
+     */
+    TTS_UTTERANCE_STARTED: 0,
+    /**
+     * Utterance was successfully finished.
+     */
+    TTS_UTTERANCE_ENDED: 1,
+    /**
+     * Utterance was canceled, or TTS service was unable to process it.
+     */
+    TTS_UTTERANCE_CANCELED: 2,
+    /**
+     * Utterance reached a word or sentence boundary.
+     */
+    TTS_UTTERANCE_BOUNDARY: 3,
+} as const;
+
+export type TTSUtteranceEvent = (typeof TTSUtteranceEvent)[keyof typeof TTSUtteranceEvent];
+