@ringozz/godot 0.1.0

package/gen/classes/PopupMenu.ts

@@ -0,0 +1,567 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Popup } from './Popup.ts';
+import type { Key } from '../global-enums.ts';
+import type { Signal, Variant } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+import type { TextDirection } from './Control.ts';
+import type { InputEvent } from './InputEvent.ts';
+import type { SystemMenus } from './NativeMenu.ts';
+import type { AutoTranslateMode } from './Node.ts';
+import type { Shortcut } from './Shortcut.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link PopupMenu} is a modal window used to display a list of options. Useful for toolbars and context menus.
+ * The size of a {@link PopupMenu} can be limited by using {@link Window.maxSize}. If the height of the list of items is larger than the maximum height of the {@link PopupMenu}, a {@link ScrollContainer} within the popup will allow the user to scroll the contents. If no maximum size is set, or if it is set to `0`, the {@link PopupMenu} height will be limited by its parent rect.
+ * All `set_*` methods allow negative item indices, i.e. `-1` to access the last item, `-2` to select the second-to-last item, and so on.
+ * **Incremental search:** Like {@link ItemList} and {@link Tree}, {@link PopupMenu} supports searching within the list while the control is focused. Press a key that matches the first letter of an item's name to select the first item starting with the given letter. After that point, there are two ways to perform incremental search: 1) Press the same key again before the timeout duration to select the next item starting with the same letter. 2) Press letter keys that match the rest of the word before the timeout duration to match to select the item in question directly. Both of these actions will be reset to the beginning of the list if the timeout duration has passed since the last keystroke was registered. You can adjust the timeout duration by changing {@link ProjectSettings.gui/timers/incrementalSearchMaxIntervalMsec}.
+ * **Note:** {@link PopupMenu} is invisible by default. To make it visible, call one of the `popup_*` methods from {@link Window} on the node, such as {@link Window.popupCenteredClamped}.
+ * **Note:** The ID values used for items are limited to 32 bits, not full 64 bits of {@link int}. This has a range of `-2^32` to `2^32 - 1`, i.e. `-2147483648` to `2147483647`.
+ */
+export class PopupMenu extends Popup {
+    constructor(name = 604) { super(name); }
+
+    /**
+     * Checks the provided `event` against the {@link PopupMenu}'s shortcuts and accelerators, and activates the first item with matching events. If `forGlobalOnly` is `true`, only shortcuts and accelerators with `global` set to `true` will be called.
+     * Returns `true` if an item was successfully activated.
+     * **Note:** Certain {@link Control}s, such as {@link MenuButton}, will call this method automatically.
+     */
+    activateItemByEvent(event: InputEvent, forGlobalOnly?: boolean /* = false */): boolean { return _C(this, 1174, event, forGlobalOnly) as boolean; }
+
+    /**
+     * Returns `true` if the system native menu is supported and currently used by this {@link PopupMenu}.
+     */
+    isNativeMenu(): boolean { return _C(this, 8126) as boolean; }
+
+    /**
+     * Adds a new item with text `label`.
+     * An `id` can optionally be provided, as well as an accelerator (`accel`). If no `id` is provided, one will be created from the index. If no `accel` is provided, then the default value of 0 (corresponding to {@link KEY_NONE}) will be assigned to the item (which means it won't have any accelerator). See {@link getItemAccelerator} for more info on accelerators.
+     * **Note:** The provided `id` is used only in {@link id_pressed} and {@link id_focused} signals. It's not related to the `index` arguments in e.g. {@link setItemChecked}.
+     */
+    addItem(label: string, id?: number /* = -1 */, accel?: Key /* = 0 */): void { _C(this, 1241, label, id, accel); }
+
+    /**
+     * Adds a new item with text `label` and icon `texture`.
+     * An `id` can optionally be provided, as well as an accelerator (`accel`). If no `id` is provided, one will be created from the index. If no `accel` is provided, then the default value of 0 (corresponding to {@link KEY_NONE}) will be assigned to the item (which means it won't have any accelerator). See {@link getItemAccelerator} for more info on accelerators.
+     */
+    addIconItem(texture: Texture2D, label: string, id?: number /* = -1 */, accel?: Key /* = 0 */): void { _C(this, 1230, texture, label, id, accel); }
+
+    /**
+     * Adds a new checkable item with text `label`.
+     * An `id` can optionally be provided, as well as an accelerator (`accel`). If no `id` is provided, one will be created from the index. If no `accel` is provided, then the default value of 0 (corresponding to {@link KEY_NONE}) will be assigned to the item (which means it won't have any accelerator). See {@link getItemAccelerator} for more info on accelerators.
+     * **Note:** Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See {@link setItemChecked} for more info on how to control it.
+     */
+    addCheckItem(label: string, id?: number /* = -1 */, accel?: Key /* = 0 */): void { _C(this, 1194, label, id, accel); }
+
+    /**
+     * Adds a new checkable item with text `label` and icon `texture`.
+     * An `id` can optionally be provided, as well as an accelerator (`accel`). If no `id` is provided, one will be created from the index. If no `accel` is provided, then the default value of 0 (corresponding to {@link KEY_NONE}) will be assigned to the item (which means it won't have any accelerator). See {@link getItemAccelerator} for more info on accelerators.
+     * **Note:** Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See {@link setItemChecked} for more info on how to control it.
+     */
+    addIconCheckItem(texture: Texture2D, label: string, id?: number /* = -1 */, accel?: Key /* = 0 */): void { _C(this, 1228, texture, label, id, accel); }
+
+    /**
+     * Adds a new radio check button with text `label`.
+     * An `id` can optionally be provided, as well as an accelerator (`accel`). If no `id` is provided, one will be created from the index. If no `accel` is provided, then the default value of 0 (corresponding to {@link KEY_NONE}) will be assigned to the item (which means it won't have any accelerator). See {@link getItemAccelerator} for more info on accelerators.
+     * **Note:** Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See {@link setItemChecked} for more info on how to control it.
+     */
+    addRadioCheckItem(label: string, id?: number /* = -1 */, accel?: Key /* = 0 */): void { _C(this, 1279, label, id, accel); }
+
+    /**
+     * Same as {@link addIconCheckItem}, but uses a radio check button.
+     */
+    addIconRadioCheckItem(texture: Texture2D, label: string, id?: number /* = -1 */, accel?: Key /* = 0 */): void { _C(this, 1231, texture, label, id, accel); }
+
+    /**
+     * Adds a new multistate item with text `label`.
+     * Contrarily to normal binary items, multistate items can have more than two states, as defined by `maxStates`. The default value is defined by `defaultState`.
+     * An `id` can optionally be provided, as well as an accelerator (`accel`). If no `id` is provided, one will be created from the index. If no `accel` is provided, then the default value of 0 (corresponding to {@link KEY_NONE}) will be assigned to the item (which means it won't have any accelerator). See {@link getItemAccelerator} for more info on accelerators.
+     *
+     * ```text
+     *
+     * func _ready():
+     * 	add_multistate_item("Item", 3, 0)
+     *
+     * 	index_pressed.connect(func(index: int):
+     * 			toggle_item_multistate(index)
+     * 			match get_item_multistate(index):
+     * 				0:
+     * 					print("First state")
+     * 				1:
+     * 					print("Second state")
+     * 				2:
+     * 					print("Third state")
+     * 		)
+     *
+     * ```
+     *
+     * **Note:** Multistate items don't update their state automatically and must be done manually. See {@link toggleItemMultistate}, {@link setItemMultistate} and {@link getItemMultistate} for more info on how to control it.
+     */
+    addMultistateItem(label: string, maxStates: number, defaultState?: number /* = 0 */, id?: number /* = -1 */, accel?: Key /* = 0 */): void { _C(this, 1253, label, maxStates, defaultState, id, accel); }
+
+    /**
+     * Adds a {@link Shortcut}.
+     * An `id` can optionally be provided. If no `id` is provided, one will be created from the index.
+     * If `allowEcho` is `true`, the shortcut can be activated with echo events.
+     */
+    addShortcut(shortcut: Shortcut, id?: number /* = -1 */, global?: boolean /* = false */, allowEcho?: boolean /* = false */): void { _C(this, 1288, shortcut, id, global, allowEcho); }
+
+    /**
+     * Adds a new item and assigns the specified {@link Shortcut} and icon `texture` to it. Sets the label of the checkbox to the {@link Shortcut}'s name.
+     * An `id` can optionally be provided. If no `id` is provided, one will be created from the index.
+     * If `allowEcho` is `true`, the shortcut can be activated with echo events.
+     */
+    addIconShortcut(texture: Texture2D, shortcut: Shortcut, id?: number /* = -1 */, global?: boolean /* = false */, allowEcho?: boolean /* = false */): void { _C(this, 1233, texture, shortcut, id, global, allowEcho); }
+
+    /**
+     * Adds a new checkable item and assigns the specified {@link Shortcut} to it. Sets the label of the checkbox to the {@link Shortcut}'s name.
+     * An `id` can optionally be provided. If no `id` is provided, one will be created from the index.
+     * **Note:** Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See {@link setItemChecked} for more info on how to control it.
+     */
+    addCheckShortcut(shortcut: Shortcut, id?: number /* = -1 */, global?: boolean /* = false */): void { _C(this, 1195, shortcut, id, global); }
+
+    /**
+     * Adds a new checkable item and assigns the specified {@link Shortcut} and icon `texture` to it. Sets the label of the checkbox to the {@link Shortcut}'s name.
+     * An `id` can optionally be provided. If no `id` is provided, one will be created from the index.
+     * **Note:** Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See {@link setItemChecked} for more info on how to control it.
+     */
+    addIconCheckShortcut(texture: Texture2D, shortcut: Shortcut, id?: number /* = -1 */, global?: boolean /* = false */): void { _C(this, 1229, texture, shortcut, id, global); }
+
+    /**
+     * Adds a new radio check button and assigns a {@link Shortcut} to it. Sets the label of the checkbox to the {@link Shortcut}'s name.
+     * An `id` can optionally be provided. If no `id` is provided, one will be created from the index.
+     * **Note:** Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually. See {@link setItemChecked} for more info on how to control it.
+     */
+    addRadioCheckShortcut(shortcut: Shortcut, id?: number /* = -1 */, global?: boolean /* = false */): void { _C(this, 1280, shortcut, id, global); }
+
+    /**
+     * Same as {@link addIconCheckShortcut}, but uses a radio check button.
+     */
+    addIconRadioCheckShortcut(texture: Texture2D, shortcut: Shortcut, id?: number /* = -1 */, global?: boolean /* = false */): void { _C(this, 1232, texture, shortcut, id, global); }
+
+    /**
+     * Adds an item that will act as a submenu of the parent {@link PopupMenu} node when clicked. The `submenu` argument must be the name of an existing {@link PopupMenu} that has been added as a child to this node. This submenu will be shown when the item is clicked, hovered for long enough, or activated using the `ui_select` or `ui_right` input actions.
+     * An `id` can optionally be provided. If no `id` is provided, one will be created from the index.
+     */
+    addSubmenuItem(label: string, submenu: string, id?: number /* = -1 */): void { _C(this, 1299, label, submenu, id); }
+
+    /**
+     * Adds an item that will act as a submenu of the parent {@link PopupMenu} node when clicked. This submenu will be shown when the item is clicked, hovered for long enough, or activated using the `ui_select` or `ui_right` input actions.
+     * `submenu` must be either child of this {@link PopupMenu} or has no parent node (in which case it will be automatically added as a child). If the `submenu` popup has another parent, this method will fail.
+     * An `id` can optionally be provided. If no `id` is provided, one will be created from the index.
+     */
+    addSubmenuNodeItem(label: string, submenu: PopupMenu, id?: number /* = -1 */): void { _C(this, 1300, label, submenu, id); }
+
+    /**
+     * Sets the text of the item at the given `index`.
+     */
+    setItemText(index: number, text: string): void { _C(this, 11806, index, text); }
+
+    /**
+     * Sets item's text base writing direction.
+     */
+    setItemTextDirection(index: number, direction: TextDirection): void { _C(this, 11807, index, direction); }
+
+    /**
+     * Sets the language code of the text for the item at the given index to `language`. This is used for line-breaking and text shaping algorithms. If `language` is empty, the current locale is used.
+     */
+    setItemLanguage(index: number, language: string): void { _C(this, 11783, index, language); }
+
+    /**
+     * Sets the auto translate mode of the item at the given `index`.
+     * Items use {@link Node.AUTO_TRANSLATE_MODE_INHERIT} by default, which uses the same auto translate mode as the {@link PopupMenu} itself.
+     */
+    setItemAutoTranslateMode(index: number, mode: AutoTranslateMode): void { _C(this, 11762, index, mode); }
+
+    /**
+     * Replaces the {@link Texture2D} icon of the item at the given `index`.
+     */
+    setItemIcon(index: number, icon: Texture2D): void { _C(this, 11773, index, icon); }
+
+    /**
+     * Sets the maximum allowed width of the icon for the item at the given `index`. This limit is applied on top of the default size of the icon and on top of {@link icon_max_width}. The height is adjusted according to the icon's ratio.
+     */
+    setItemIconMaxWidth(index: number, width: number): void { _C(this, 11774, index, width); }
+
+    /**
+     * Sets a modulating {@link Color} of the item's icon at the given `index`.
+     */
+    setItemIconModulate(index: number, modulate: Color): void { _C(this, 11775, index, modulate); }
+
+    /**
+     * Sets the checkstate status of the item at the given `index`.
+     */
+    setItemChecked(index: number, checked: boolean): void { _C(this, 11765, index, checked); }
+
+    /**
+     * Sets the `id` of the item at the given `index`.
+     * The `id` is used in {@link id_pressed} and {@link id_focused} signals.
+     */
+    setItemId(index: number, id: number): void { _C(this, 11778, index, id); }
+
+    /**
+     * Sets the accelerator of the item at the given `index`. An accelerator is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. `accel` is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`).
+     */
+    setItemAccelerator(index: number, accel: Key): void { _C(this, 11758, index, accel); }
+
+    /**
+     * Sets the metadata of an item, which may be of any type. You can later get it with {@link getItemMetadata}, which provides a simple way of assigning context data to items.
+     */
+    setItemMetadata(index: number, metadata: Variant): void { _C(this, 11788, index, metadata); }
+
+    /**
+     * Enables/disables the item at the given `index`. When it is disabled, it can't be selected and its action can't be invoked.
+     */
+    setItemDisabled(index: number, disabled: boolean): void { _C(this, 11770, index, disabled); }
+
+    /**
+     * Sets the submenu of the item at the given `index`. The submenu is the name of a child {@link PopupMenu} node that would be shown when the item is clicked.
+     */
+    setItemSubmenu(index: number, submenu: string): void { _C(this, 11803, index, submenu); }
+
+    /**
+     * Sets the submenu of the item at the given `index`. The submenu is a {@link PopupMenu} node that would be shown when the item is clicked. It must either be a child of this {@link PopupMenu} or has no parent (in which case it will be automatically added as a child). If the `submenu` popup has another parent, this method will fail.
+     */
+    setItemSubmenuNode(index: number, submenu: PopupMenu): void { _C(this, 11804, index, submenu); }
+
+    /**
+     * Mark the item at the given `index` as a separator, which means that it would be displayed as a line. If `false`, sets the type of the item to plain text.
+     */
+    setItemAsSeparator(index: number, enable: boolean): void { _C(this, 11761, index, enable); }
+
+    /**
+     * Sets whether the item at the given `index` has a checkbox. If `false`, sets the type of the item to plain text.
+     * **Note:** Checkable items just display a checkmark, but don't have any built-in checking behavior and must be checked/unchecked manually.
+     */
+    setItemAsCheckable(index: number, enable: boolean): void { _C(this, 11759, index, enable); }
+
+    /**
+     * Sets the type of the item at the given `index` to radio button. If `false`, sets the type of the item to plain text.
+     */
+    setItemAsRadioCheckable(index: number, enable: boolean): void { _C(this, 11760, index, enable); }
+
+    /**
+     * Sets the {@link String} tooltip of the item at the given `index`.
+     */
+    setItemTooltip(index: number, tooltip: string): void { _C(this, 11808, index, tooltip); }
+
+    /**
+     * Sets a {@link Shortcut} for the item at the given `index`.
+     */
+    setItemShortcut(index: number, shortcut: Shortcut, global?: boolean /* = false */): void { _C(this, 11800, index, shortcut, global); }
+
+    /**
+     * Sets the horizontal offset of the item at the given `index`.
+     */
+    setItemIndent(index: number, indent: number): void { _C(this, 11779, index, indent); }
+
+    /**
+     * Sets the state of a multistate item. See {@link addMultistateItem} for details.
+     */
+    setItemMultistate(index: number, state: number): void { _C(this, 11789, index, state); }
+
+    /**
+     * Sets the max states of a multistate item. See {@link addMultistateItem} for details.
+     */
+    setItemMultistateMax(index: number, maxStates: number): void { _C(this, 11790, index, maxStates); }
+
+    /**
+     * Disables the {@link Shortcut} of the item at the given `index`.
+     */
+    setItemShortcutDisabled(index: number, disabled: boolean): void { _C(this, 11801, index, disabled); }
+
+    /**
+     * Changes the index of the item at index `index` to be at index `targetIndex`. This can be used to move an item above other items. The moved item will keep the same ID, even if it was generated from the original index.
+     * **Note:** The indices of any items between index `index` and index `targetIndex` will be shifted by one.
+     */
+    setItemIndex(index: number, targetIndex: number): void { _C(this, 11781, index, targetIndex); }
+
+    /**
+     * Toggles the check state of the item at the given `index`.
+     */
+    toggleItemChecked(index: number): void { _C(this, 14323, index); }
+
+    /**
+     * Cycle to the next state of a multistate item. See {@link addMultistateItem} for details.
+     */
+    toggleItemMultistate(index: number): void { _C(this, 14324, index); }
+
+    /**
+     * Returns the text of the item at the given `index`.
+     */
+    getItemText(index: number): string { return _C(this, 5216, index) as string; }
+
+    /**
+     * Returns item's text base writing direction.
+     */
+    getItemTextDirection(index: number): TextDirection { return _C(this, 5217, index) as TextDirection; }
+
+    /**
+     * Returns item's text language code.
+     */
+    getItemLanguage(index: number): string { return _C(this, 5194, index) as string; }
+
+    /**
+     * Returns the auto translate mode of the item at the given `index`.
+     */
+    getItemAutoTranslateMode(index: number): AutoTranslateMode { return _C(this, 5179, index) as AutoTranslateMode; }
+
+    /**
+     * Returns the icon of the item at the given `index`.
+     */
+    getItemIcon(index: number): Texture2D { return _C(this, 5185, index) as Texture2D; }
+
+    /**
+     * Returns the maximum allowed width of the icon for the item at the given `index`.
+     */
+    getItemIconMaxWidth(index: number): number { return _C(this, 5186, index) as number; }
+
+    /**
+     * Returns a {@link Color} modulating the item's icon at the given `index`.
+     */
+    getItemIconModulate(index: number): Color { return _C(this, 5187, index) as Color; }
+
+    /**
+     * Returns `true` if the item at the given `index` is checked.
+     */
+    isItemChecked(index: number): boolean { return _C(this, 8039, index) as boolean; }
+
+    /**
+     * Returns the ID of the item at the given `index`.
+     */
+    getItemId(index: number): number { return _C(this, 5189, index) as number; }
+
+    /**
+     * Returns the index of the item containing the specified `id`. The index is automatically assigned to each item by the engine when added and represents the order items will be displayed.
+     */
+    getItemIndex(id: number): number { return _C(this, 5192, id) as number; }
+
+    /**
+     * Returns the accelerator of the item at the given `index`. An accelerator is a keyboard shortcut that can be pressed to trigger the menu button even if it's not currently open. The return value is an integer which is generally a combination of {@link KeyModifierMask}s and {@link Key}s using bitwise OR such as `KEY_MASK_CTRL | KEY_A` (`Ctrl + A`). If no accelerator is defined for the specified `index`, {@link getItemAccelerator} returns `0` (corresponding to {@link KEY_NONE}).
+     */
+    getItemAccelerator(index: number): Key { return _C(this, 5176, index) as Key; }
+
+    /**
+     * Returns the metadata of the specified item, which might be of any type. You can set it with {@link setItemMetadata}, which provides a simple way of assigning context data to items.
+     */
+    getItemMetadata(index: number): Variant { return _C(this, 5200, index) as Variant; }
+
+    /**
+     * Returns `true` if the item at the given `index` is disabled. When it is disabled it can't be selected, or its action invoked.
+     * See {@link setItemDisabled} for more info on how to disable an item.
+     */
+    isItemDisabled(index: number): boolean { return _C(this, 8040, index) as boolean; }
+
+    /**
+     * Returns the submenu name of the item at the given `index`. See {@link addSubmenuItem} for more info on how to add a submenu.
+     */
+    getItemSubmenu(index: number): string { return _C(this, 5213, index) as string; }
+
+    /**
+     * Returns the submenu of the item at the given `index`, or `null` if no submenu was added. See {@link addSubmenuNodeItem} for more info on how to add a submenu.
+     */
+    getItemSubmenuNode(index: number): PopupMenu | null { return _C(this, 5214, index) as PopupMenu | null; }
+
+    /**
+     * Returns `true` if the item is a separator. If it is, it will be displayed as a line. See {@link addSeparator} for more info on how to add a separator.
+     */
+    isItemSeparator(index: number): boolean { return _C(this, 8045, index) as boolean; }
+
+    /**
+     * Returns `true` if the item at the given `index` is checkable in some way, i.e. if it has a checkbox or radio button.
+     * **Note:** Checkable items just display a checkmark or radio button, but don't have any built-in checking behavior and must be checked/unchecked manually.
+     */
+    isItemCheckable(index: number): boolean { return _C(this, 8038, index) as boolean; }
+
+    /**
+     * Returns `true` if the item at the given `index` has radio button-style checkability.
+     * **Note:** This is purely cosmetic; you must add the logic for checking/unchecking items in radio groups.
+     */
+    isItemRadioCheckable(index: number): boolean { return _C(this, 8043, index) as boolean; }
+
+    /**
+     * Returns `true` if the specified item's shortcut is disabled.
+     */
+    isItemShortcutDisabled(index: number): boolean { return _C(this, 8046, index) as boolean; }
+
+    /**
+     * Returns the tooltip associated with the item at the given `index`.
+     */
+    getItemTooltip(index: number): string { return _C(this, 5218, index) as string; }
+
+    /**
+     * Returns the {@link Shortcut} associated with the item at the given `index`.
+     */
+    getItemShortcut(index: number): Shortcut { return _C(this, 5211, index) as Shortcut; }
+
+    /**
+     * Returns the horizontal offset of the item at the given `index`.
+     */
+    getItemIndent(index: number): number { return _C(this, 5190, index) as number; }
+
+    /**
+     * Returns the max states of the item at the given `index`.
+     */
+    getItemMultistateMax(index: number): number { return _C(this, 5202, index) as number; }
+
+    /**
+     * Returns the state of the item at the given `index`.
+     */
+    getItemMultistate(index: number): number { return _C(this, 5201, index) as number; }
+
+    /**
+     * Sets the currently focused item as the given `index`.
+     * Passing `-1` as the index makes so that no item is focused.
+     */
+    setFocusedItem(index: number): void { _C(this, 11431, index); }
+
+    /**
+     * Returns the index of the currently focused item. Returns `-1` if no item is focused.
+     */
+    getFocusedItem(): number { return _C(this, 4827) as number; }
+
+    /**
+     * Moves the scroll view to make the item at the given `index` visible.
+     */
+    scrollToItem(index: number): void { _C(this, 10295, index); }
+
+    /**
+     * Removes the item at the given `index` from the menu.
+     * **Note:** The indices of items after the removed item will be shifted by one.
+     */
+    removeItem(index: number): void { _C(this, 9924, index); }
+
+    /**
+     * Adds a separator between items. Separators also occupy an index, which you can set by using the `id` parameter.
+     * A `label` can optionally be provided, which will appear at the center of the separator.
+     */
+    addSeparator(label?: string /* = "" */, id?: number /* = -1 */): void { _C(this, 1286, label, id); }
+
+    /**
+     * Removes all items from the {@link PopupMenu}. If `freeSubmenus` is `true`, the submenu nodes are automatically freed.
+     */
+    clear(freeSubmenus?: boolean /* = false */): void { _C(this, 2232, freeSubmenus); }
+
+    /**
+     * Returns `true` if the menu is bound to the special system menu.
+     */
+    isSystemMenu(): boolean { return _C(this, 8354) as boolean; }
+
+    /**
+     * If `true`, hides the {@link PopupMenu} when an item is selected.
+     */
+    get hideOnItemSelection(): boolean { return _C(this, 7993) as boolean; }
+    set hideOnItemSelection(v: boolean) { _C(this, 11625, v); }
+
+    /**
+     * If `true`, hides the {@link PopupMenu} when a checkbox or radio button is selected.
+     */
+    get hideOnCheckableItemSelection(): boolean { return _C(this, 7992) as boolean; }
+    set hideOnCheckableItemSelection(v: boolean) { _C(this, 11624, v); }
+
+    /**
+     * If `true`, hides the {@link PopupMenu} when a state item is selected.
+     */
+    get hideOnStateItemSelection(): boolean { return _C(this, 7994) as boolean; }
+    set hideOnStateItemSelection(v: boolean) { _C(this, 11627, v); }
+
+    /**
+     * Sets the delay time in seconds for the submenu item to popup on mouse hovering. If the popup menu is added as a child of another (acting as a submenu), it will inherit the delay time of the parent menu item.
+     * **Note:** If the mouse is exiting a submenu item with an open submenu and enters a different submenu item, the submenu popup delay time is affected by the direction of the mouse movement toward the open submenu. If the mouse is moving toward the submenu, the open submenu will wait approximately `0.5` seconds before closing, which then allows the hovered submenu item to open. This additional delay allows the mouse time to move to the open submenu across other menu items without prematurely closing. If the mouse is not moving toward the open submenu, for example in a downward direction, the open submenu will close immediately.
+     */
+    get submenuPopupDelay(): number { return _C(this, 6602) as number; }
+    set submenuPopupDelay(v: number) { _C(this, 12928, v); }
+
+    /**
+     * If `true`, allows navigating {@link PopupMenu} with letter keys.
+     */
+    get allowSearch(): boolean { return _C(this, 3721) as boolean; }
+    set allowSearch(v: boolean) { _C(this, 10459, v); }
+
+    /**
+     * If set to one of the values of {@link NativeMenu.SystemMenus}, this {@link PopupMenu} is bound to the special system menu. Only one {@link PopupMenu} can be bound to each special menu at a time.
+     */
+    get systemMenuId(): SystemMenus { return _C(this, 6663) as SystemMenus; }
+    set systemMenuId(v: SystemMenus) { _C(this, 12965, v); }
+
+    /**
+     * If `true`, {@link MenuBar} will use native menu when supported.
+     * **Note:** If {@link PopupMenu} is linked to {@link StatusIndicator}, {@link MenuBar}, or another {@link PopupMenu} item it can use native menu regardless of this property, use {@link isNativeMenu} to check it.
+     */
+    get preferNativeMenu(): boolean { return _C(this, 8198) as boolean; }
+    set preferNativeMenu(v: boolean) { _C(this, 12397, v); }
+
+    /**
+     * If `true`, shrinks {@link PopupMenu} to minimum height when it's shown.
+     */
+    get shrinkHeight(): boolean { return _C(this, 6383) as boolean; }
+    set shrinkHeight(v: boolean) { _C(this, 12741, v); }
+
+    /**
+     * If `true`, shrinks {@link PopupMenu} to minimum width when it's shown.
+     */
+    get shrinkWidth(): boolean { return _C(this, 6384) as boolean; }
+    set shrinkWidth(v: boolean) { _C(this, 12742, v); }
+
+    /**
+     * If `true`, shows a search bar at the top of the {@link PopupMenu} for filtering items. See {@link searchBarMinItemCount} for dynamically controlling its visibility based on the number of items.
+     * **Note:** When enabled, {@link allowSearch} is ignored.
+     */
+    get searchBarEnabled(): boolean { return _C(this, 8282) as boolean; }
+    set searchBarEnabled(v: boolean) { _C(this, 12662, v); }
+
+    /**
+     * Sets the minimum number of items required for the search bar to be visible. {@link searchBarEnabled} must be `true` for this to have any effect. Separator items are not counted.
+     */
+    get searchBarMinItemCount(): number { return _C(this, 6302) as number; }
+    set searchBarMinItemCount(v: number) { _C(this, 12665, v); }
+
+    /**
+     * If `true`, enables fuzzy searching in the {@link PopupMenu} search bar. This allows the search results to include items that almost match the search query, as well items that match the individual characters of the search query, but not in sequence.
+     * Use {@link searchBarFuzzySearchMaxMisses} to set the maximum number of mismatches allowed in the search results.
+     */
+    get searchBarFuzzySearchEnabled(): boolean { return _C(this, 8283) as boolean; }
+    set searchBarFuzzySearchEnabled(v: boolean) { _C(this, 12663, v); }
+
+    /**
+     * Sets the maximum number of mismatches allowed in each search result when fuzzy searching is enabled for the {@link PopupMenu} search bar. Any item with more mismatches will be hidden from the search results.
+     */
+    get searchBarFuzzySearchMaxMisses(): number { return _C(this, 6301) as number; }
+    set searchBarFuzzySearchMaxMisses(v: number) { _C(this, 12664, v); }
+
+    /**
+     * The number of items currently in the list.
+     */
+    get itemCount(): number { return _C(this, 5181) as number; }
+    set itemCount(v: number) { _C(this, 11766, v); }
+
+    /**
+     * Emitted when an item of some `id` is pressed. Also emitted when its accelerator is activated on macOS.
+     * **Note:** If `id` is negative (either explicitly or due to overflow), this will return the corresponding index instead.
+     */
+    get idPressed(): Signal<(id: number) => void> { return _G(this, 7557) as Signal<(id: number) => void>; }
+    set idPressed(v: ((id: number) => void) | null) { _G(this, 7557, v); }
+
+    /**
+     * Emitted when the user navigated to an item of some `id` using the {@link ProjectSettings.input/uiUp} or {@link ProjectSettings.input/uiDown} input action.
+     */
+    get idFocused(): Signal<(id: number) => void> { return _G(this, 7556) as Signal<(id: number) => void>; }
+    set idFocused(v: ((id: number) => void) | null) { _G(this, 7556, v); }
+
+    /**
+     * Emitted when an item of some `index` is pressed. Also emitted when its accelerator is activated on macOS.
+     */
+    get indexPressed(): Signal<(index: number) => void> { return _G(this, 7598) as Signal<(index: number) => void>; }
+    set indexPressed(v: ((index: number) => void) | null) { _G(this, 7598, v); }
+
+    /**
+     * Emitted when any item is added, modified or removed.
+     */
+    get menuChanged(): Signal<() => void> { return _G(this, 8848) as Signal<() => void>; }
+    set menuChanged(v: (() => void) | null) { _G(this, 8848, v); }
+
+    static readonly name = _R(604, PopupMenu);
+}

package/gen/classes/PopupPanel.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Popup } from './Popup.ts';
+
+/**
+ * A popup with a configurable panel background. Any child controls added to this node will be stretched to fit the panel's size (similar to how {@link PanelContainer} works). If you are making windows, see {@link Window}.
+ */
+export class PopupPanel extends Popup {
+    constructor(name = 605) { super(name); }
+
+    static readonly name = _R(605, PopupPanel);
+}

package/gen/classes/PortableCompressedTexture2D.ts

@@ -0,0 +1,74 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * This class allows storing compressed textures as self contained (not imported) resources.
+ * For 2D usage (compressed on disk, uncompressed on VRAM), the lossy and lossless modes are recommended. For 3D usage (compressed on VRAM) it depends on the target platform.
+ * If you intend to only use desktop, S3TC or BPTC are recommended. For only mobile, ETC2 is recommended.
+ * For portable, self contained 3D textures that work on both desktop and mobile, Basis Universal is recommended (although it has a small quality cost and longer compression time as a tradeoff).
+ * This resource is intended to be created from code.
+ */
+export class PortableCompressedTexture2D extends Texture2D {
+    constructor(name = 606) { super(name); }
+
+    /**
+     * Initializes the compressed texture from a base image. The compression mode must be provided.
+     * `normalMap` is recommended to ensure optimum quality if this image will be used as a normal map.
+     * If lossy compression is requested, the quality setting can optionally be provided. This maps to Lossy WebP compression quality.
+     */
+    createFromImage(image: Image, compressionMode: CompressionMode, normalMap?: boolean /* = false */, lossyQuality?: number /* = 0.8 */): void { _C(this, 2533, image, compressionMode, normalMap, lossyQuality); }
+
+    /**
+     * Return the compression mode used (valid after initialized).
+     */
+    getCompressionMode(): CompressionMode { return _C(this, 4253) as CompressionMode; }
+
+    /**
+     * Sets the compressor parameters for Basis Universal compression. See also the settings in {@link ResourceImporterTexture}.
+     * **Note:** This method must be called before {@link createFromImage} for this to work.
+     */
+    setBasisuCompressorParams(uastcLevel: number, rdoQualityLoss: number): void { _C(this, 10648, uastcLevel, rdoQualityLoss); }
+
+    /**
+     * If `keep` is `true`, overrides the flag globally for all textures of this type. This is used primarily by the editor.
+     */
+    static setKeepAllCompressedBuffers(keep: boolean): void { _C(606, 11856, keep); }
+
+    /**
+     * Returns `true` if the flag is overridden for all textures of this type.
+     */
+    static isKeepingAllCompressedBuffers(): boolean { return _C(606, 8058) as boolean; }
+
+    /**
+     * Allows overriding the texture's size (for 2D only).
+     */
+    get sizeOverride(): Vector2 { return _C(this, 6403) as Vector2; }
+    set sizeOverride(v: Vector2) { _C(this, 12756, v); }
+
+    /**
+     * If `true`, when running in the editor, this texture will keep the source-compressed data in memory, allowing the data to persist after loading. Otherwise, the source-compressed data is lost after loading and the texture can't be re-saved.
+     * **Note:** This property must be set before {@link createFromImage} for this to work.
+     */
+    get keepCompressedBuffer(): boolean { return _C(this, 8059) as boolean; }
+    set keepCompressedBuffer(v: boolean) { _C(this, 11858, v); }
+
+    static readonly name = _R(606, PortableCompressedTexture2D);
+}
+
+export const CompressionMode = {
+    COMPRESSION_MODE_LOSSLESS: 0,
+    COMPRESSION_MODE_LOSSY: 1,
+    COMPRESSION_MODE_BASIS_UNIVERSAL: 2,
+    COMPRESSION_MODE_S3TC: 3,
+    COMPRESSION_MODE_ETC2: 4,
+    COMPRESSION_MODE_BPTC: 5,
+    COMPRESSION_MODE_ASTC: 6,
+} as const;
+
+export type CompressionMode = (typeof CompressionMode)[keyof typeof CompressionMode];
+