@ringozz/godot 0.1.0

package/gen/classes/InputEvent.ts

@@ -0,0 +1,112 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { StringName } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+
+/**
+ * Abstract base class of all types of input events. See {@link Node.Input}.
+ */
+export class InputEvent extends Resource {
+
+    /**
+     * Returns `true` if this input event matches a pre-defined action of any type.
+     * If `exactMatch` is `false`, it ignores additional input modifiers for {@link InputEventKey} and {@link InputEventMouseButton} events, and the direction for {@link InputEventJoypadMotion} events.
+     */
+    isAction(action: StringName, exactMatch?: boolean /* = false */): boolean { return _C(this, 7737, action, exactMatch) as boolean; }
+
+    /**
+     * Returns `true` if the given action matches this event and is being pressed (and is not an echo event for {@link InputEventKey} events, unless `allowEcho` is `true`). Not relevant for events of type {@link InputEventMouseMotion} or {@link InputEventScreenDrag}.
+     * If `exactMatch` is `false`, it ignores additional input modifiers for {@link InputEventKey} and {@link InputEventMouseButton} events, and the direction for {@link InputEventJoypadMotion} events.
+     * **Note:** Due to keyboard ghosting, {@link isActionPressed} may return `false` even if one of the action's keys is pressed. See [Input examples]($DOCS_URL/tutorials/inputs/input_examples.html#keyboard-events) in the documentation for more information.
+     */
+    isActionPressed(action: StringName, allowEcho?: boolean /* = false */, exactMatch?: boolean /* = false */): boolean { return _C(this, 7742, action, allowEcho, exactMatch) as boolean; }
+
+    /**
+     * Returns `true` if the given action matches this event and is released (i.e. not pressed). Not relevant for events of type {@link InputEventMouseMotion} or {@link InputEventScreenDrag}.
+     * If `exactMatch` is `false`, it ignores additional input modifiers for {@link InputEventKey} and {@link InputEventMouseButton} events, and the direction for {@link InputEventJoypadMotion} events.
+     */
+    isActionReleased(action: StringName, exactMatch?: boolean /* = false */): boolean { return _C(this, 7743, action, exactMatch) as boolean; }
+
+    /**
+     * Returns a value between 0.0 and 1.0 depending on the given actions' state. Useful for getting the value of events of type {@link InputEventJoypadMotion}.
+     * If `exactMatch` is `false`, it ignores additional input modifiers for {@link InputEventKey} and {@link InputEventMouseButton} events, and the direction for {@link InputEventJoypadMotion} events.
+     */
+    getActionStrength(action: StringName, exactMatch?: boolean /* = false */): number { return _C(this, 3688, action, exactMatch) as number; }
+
+    /**
+     * Returns `true` if this input event has been canceled.
+     */
+    isCanceled(): boolean { return _C(this, 7814) as boolean; }
+
+    /**
+     * Returns `true` if this input event is pressed. Not relevant for events of type {@link InputEventMouseMotion} or {@link InputEventScreenDrag}.
+     * **Note:** Due to keyboard ghosting, {@link isPressed} may return `false` even if one of the action's keys is pressed. See [Input examples]($DOCS_URL/tutorials/inputs/input_examples.html#keyboard-events) in the documentation for more information.
+     */
+    isPressed(): boolean { return _C(this, 8199) as boolean; }
+
+    /**
+     * Returns `true` if this input event is released. Not relevant for events of type {@link InputEventMouseMotion} or {@link InputEventScreenDrag}.
+     */
+    isReleased(): boolean { return _C(this, 8239) as boolean; }
+
+    /**
+     * Returns `true` if this input event is an echo event (only for events of type {@link InputEventKey}). An echo event is a repeated key event sent when the user is holding down the key. Any other event type returns `false`.
+     * **Note:** The rate at which echo events are sent is typically around 20 events per second (after holding down the key for roughly half a second). However, the key repeat delay/speed can be changed by the user or disabled entirely in the operating system settings. To ensure your project works correctly on all configurations, do not assume the user has a specific key repeat configuration in your project's behavior.
+     */
+    isEcho(): boolean { return _C(this, 7914) as boolean; }
+
+    /**
+     * Returns a {@link String} representation of the event.
+     */
+    asText(): string { return _C(this, 1595) as string; }
+
+    /**
+     * Returns `true` if the specified `event` matches this event. Only valid for action events, which include key ({@link InputEventKey}), button ({@link InputEventMouseButton} or {@link InputEventJoypadButton}), axis {@link InputEventJoypadMotion}, and action ({@link InputEventAction}) events.
+     * If `exactMatch` is `false`, the check ignores additional input modifiers for {@link InputEventKey} and {@link InputEventMouseButton} events, and the direction for {@link InputEventJoypadMotion} events.
+     * **Note:** This method only considers the event configuration (such as the keyboard key or the joypad axis), not state information like {@link isPressed}, {@link isReleased}, {@link isEcho}, or {@link isCanceled}.
+     */
+    isMatch(event: InputEvent, exactMatch?: boolean /* = true */): boolean { return _C(this, 8097, event, exactMatch) as boolean; }
+
+    /**
+     * Returns `true` if this input event's type is one that can be assigned to an input action: {@link InputEventKey}, {@link InputEventMouseButton}, {@link InputEventJoypadButton}, {@link InputEventJoypadMotion}, {@link InputEventAction}. Returns `false` for all other input event types.
+     */
+    isActionType(): boolean { return _C(this, 7745) as boolean; }
+
+    /**
+     * Returns `true` if the given input event and this input event can be added together (only for events of type {@link InputEventMouseMotion}).
+     * The given input event's position, global position and speed will be copied. The resulting `relative` is a sum of both events. Both events' modifiers have to be identical.
+     */
+    accumulate(withEvent: InputEvent): boolean { return _C(this, 1151, withEvent) as boolean; }
+
+    /**
+     * Returns a copy of the given input event which has been offset by `localOfs` and transformed by `xform`. Relevant for events of type {@link InputEventMouseButton}, {@link InputEventMouseMotion}, {@link InputEventScreenTouch}, {@link InputEventScreenDrag}, {@link InputEventMagnifyGesture} and {@link InputEventPanGesture}.
+     */
+    xformedBy(xform: Transform2D, localOfs?: Vector2 /* = Vector2(0, 0) */): InputEvent { return _C(this, 14947, xform, localOfs) as InputEvent; }
+
+    /**
+     * The event's device ID.
+     * **Note:** {@link device} can be negative for special use cases that don't refer to devices physically present on the system. See {@link DEVICE_ID_EMULATION}.
+     */
+    get device(): number { return _C(this, 4491) as number; }
+    set device(v: number) { _C(this, 11106, v); }
+
+    /**
+     * Device ID used for emulated mouse input from a touchscreen, or for emulated touch input from a mouse. This can be used to distinguish emulated mouse input from physical mouse input, or emulated touch input from physical touch input.
+     */
+    static readonly DEVICE_ID_EMULATION = -1;
+
+    /**
+     * Device ID used for input from a keyboard. This can be used to distinguish keyboard input events from joypad input events.
+     */
+    static readonly DEVICE_ID_KEYBOARD = 16;
+
+    /**
+     * Device ID used for input from a mouse. This can be used to distinguish mouse input events from joypad input events.
+     */
+    static readonly DEVICE_ID_MOUSE = 32;
+
+    static readonly name = _R(348, InputEvent);
+}

package/gen/classes/InputEventAction.ts

@@ -0,0 +1,40 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEvent } from './InputEvent.ts';
+import type { StringName } from '../heap-types/index.ts';
+
+/**
+ * Contains a generic action which can be targeted from several types of inputs. Actions and their events can be set in the **Input Map** tab in **Project > Project Settings**, or with the {@link InputMap} class.
+ * **Note:** Unlike the other {@link InputEvent} subclasses which map to unique physical events, this virtual one is not emitted by the engine. This class is useful to emit actions manually with {@link Input.parseInputEvent}, which are then received in {@link Node.Input}. To check if a physical event matches an action from the Input Map, use {@link InputEvent.isAction} and {@link InputEvent.isActionPressed}.
+ */
+export class InputEventAction extends InputEvent {
+    constructor(name = 349) { super(name); }
+
+    /**
+     * The action's name. This is usually the name of an existing action in the {@link InputMap} which you want this custom event to match.
+     */
+    get action(): StringName { return _C(this, 3676) as StringName; }
+    set action(v: StringName) { _C(this, 10415, v); }
+
+    /**
+     * If `true`, the action's state is pressed. If `false`, the action's state is released.
+     */
+    get pressed(): boolean { return _C(this, 8199) as boolean; }
+    set pressed(v: boolean) { _C(this, 12404, v); }
+
+    /**
+     * The action's strength between 0 and 1. This value is considered as equal to 0 if pressed is `false`. The event strength allows faking analog joypad motion events, by specifying how strongly the joypad axis is bent or pressed.
+     */
+    get strength(): number { return _C(this, 6567) as number; }
+    set strength(v: number) { _C(this, 12904, v); }
+
+    /**
+     * The real event index in action this event corresponds to (from events defined for this action in the {@link InputMap}). If `-1`, a unique ID will be used and actions pressed with this ID will need to be released with another {@link InputEventAction}.
+     */
+    get eventIndex(): number { return _C(this, 4690) as number; }
+    set eventIndex(v: number) { _C(this, 11307, v); }
+
+    static readonly name = _R(349, InputEventAction);
+}

package/gen/classes/InputEventFromWindow.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEvent } from './InputEvent.ts';
+
+/**
+ * InputEventFromWindow represents events specifically received by windows. This includes mouse events, keyboard events in focused windows or touch screen actions.
+ */
+export class InputEventFromWindow extends InputEvent {
+
+    /**
+     * The ID of a {@link Window} that received this event.
+     */
+    get windowId(): number { return _C(this, 7154) as number; }
+    set windowId(v: number) { _C(this, 13377, v); }
+
+    static readonly name = _R(350, InputEventFromWindow);
+}

package/gen/classes/InputEventGesture.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventWithModifiers } from './InputEventWithModifiers.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * InputEventGestures are sent when a user performs a supported gesture on a touch screen. Gestures can't be emulated using mouse, because they typically require multi-touch.
+ */
+export class InputEventGesture extends InputEventWithModifiers {
+
+    /**
+     * The local gesture position relative to the {@link Viewport}. If used in {@link Control.GuiInput}, the position is relative to the current {@link Control} that received this gesture.
+     */
+    get position(): Vector2 { return _C(this, 5973) as Vector2; }
+    set position(v: Vector2) { _C(this, 12381, v); }
+
+    static readonly name = _R(351, InputEventGesture);
+}

package/gen/classes/InputEventJoypadButton.ts

@@ -0,0 +1,30 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEvent } from './InputEvent.ts';
+import type { JoyButton } from '../global-enums.ts';
+
+/**
+ * Input event type for gamepad buttons. For gamepad analog sticks and joysticks, see {@link InputEventJoypadMotion}.
+ */
+export class InputEventJoypadButton extends InputEvent {
+    constructor(name = 352) { super(name); }
+
+    /**
+     * Button identifier. One of the {@link JoyButton} button constants.
+     */
+    get buttonIndex(): JoyButton { return _C(this, 4035) as JoyButton; }
+    set buttonIndex(v: JoyButton) { _C(this, 10766, v); }
+
+    get pressure(): number { return _C(this, 5996) as number; }
+    set pressure(v: number) { _C(this, 12406, v); }
+
+    /**
+     * If `true`, the button's state is pressed. If `false`, the button's state is released.
+     */
+    get pressed(): boolean { return _C(this, 8199) as boolean; }
+    set pressed(v: boolean) { _C(this, 12404, v); }
+
+    static readonly name = _R(352, InputEventJoypadButton);
+}

package/gen/classes/InputEventJoypadMotion.ts

@@ -0,0 +1,27 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEvent } from './InputEvent.ts';
+import type { JoyAxis } from '../global-enums.ts';
+
+/**
+ * Stores information about joystick motions. One {@link InputEventJoypadMotion} represents one axis at a time. For gamepad buttons, see {@link InputEventJoypadButton}.
+ */
+export class InputEventJoypadMotion extends InputEvent {
+    constructor(name = 353) { super(name); }
+
+    /**
+     * Axis identifier.
+     */
+    get axis(): JoyAxis { return _C(this, 3859) as JoyAxis; }
+    set axis(v: JoyAxis) { _C(this, 10604, v); }
+
+    /**
+     * Current position of the joystick on the given axis. The value ranges from `-1.0` to `1.0`. A value of `0` means the axis is in its resting position.
+     */
+    get axisValue(): number { return _C(this, 3862) as number; }
+    set axisValue(v: number) { _C(this, 10607, v); }
+
+    static readonly name = _R(353, InputEventJoypadMotion);
+}

package/gen/classes/InputEventKey.ts

@@ -0,0 +1,133 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventWithModifiers } from './InputEventWithModifiers.ts';
+import type { Key, KeyLocation } from '../global-enums.ts';
+
+/**
+ * An input event for keys on a keyboard. Supports key presses, key releases and {@link echo} events. It can also be received in {@link Node.UnhandledKeyInput}.
+ * **Note:** Events received from the keyboard usually have all properties set. Event mappings should have only one of the {@link keycode}, {@link physicalKeycode} or {@link unicode} set.
+ * When events are compared, properties are checked in the following priority - {@link keycode}, {@link physicalKeycode} and {@link unicode}. Events with the first matching value will be considered equal.
+ */
+export class InputEventKey extends InputEventWithModifiers {
+    constructor(name = 354) { super(name); }
+
+    /**
+     * Returns the Latin keycode combined with modifier keys such as `Shift` or `Alt`. See also {@link InputEventWithModifiers}.
+     * To get a human-readable representation of the {@link InputEventKey} with modifiers, use `OS.get_keycode_string(event.get_keycode_with_modifiers())` where `event` is the {@link InputEventKey}.
+     */
+    getKeycodeWithModifiers(): Key { return _C(this, 5294) as Key; }
+
+    /**
+     * Returns the physical keycode combined with modifier keys such as `Shift` or `Alt`. See also {@link InputEventWithModifiers}.
+     * To get a human-readable representation of the {@link InputEventKey} with modifiers, use `OS.get_keycode_string(event.get_physical_keycode_with_modifiers())` where `event` is the {@link InputEventKey}.
+     */
+    getPhysicalKeycodeWithModifiers(): Key { return _C(this, 5885) as Key; }
+
+    /**
+     * Returns the localized key label combined with modifier keys such as `Shift` or `Alt`. See also {@link InputEventWithModifiers}.
+     * To get a human-readable representation of the {@link InputEventKey} with modifiers, use `OS.get_keycode_string(event.get_key_label_with_modifiers())` where `event` is the {@link InputEventKey}.
+     */
+    getKeyLabelWithModifiers(): Key { return _C(this, 5290) as Key; }
+
+    /**
+     * Returns a {@link String} representation of the event's {@link keycode} and modifiers.
+     */
+    asTextKeycode(): string { return _C(this, 1597) as string; }
+
+    /**
+     * Returns a {@link String} representation of the event's {@link physicalKeycode} and modifiers.
+     */
+    asTextPhysicalKeycode(): string { return _C(this, 1599) as string; }
+
+    /**
+     * Returns a {@link String} representation of the event's {@link keyLabel} and modifiers.
+     */
+    asTextKeyLabel(): string { return _C(this, 1596) as string; }
+
+    /**
+     * Returns a {@link String} representation of the event's {@link location}. This will be a blank string if the event is not specific to a location.
+     */
+    asTextLocation(): string { return _C(this, 1598) as string; }
+
+    /**
+     * If `true`, the key's state is pressed. If `false`, the key's state is released.
+     */
+    get pressed(): boolean { return _C(this, 8199) as boolean; }
+    set pressed(v: boolean) { _C(this, 12404, v); }
+
+    /**
+     * Latin label printed on the key in the current keyboard layout, which corresponds to one of the {@link Key} constants. Key codes are meant for shortcuts expressed with a standard Latin keyboard, such as `Ctrl + S` for a "Save" shortcut.
+     * To get a human-readable representation of the {@link InputEventKey}, use `OS.get_keycode_string(event.keycode)` where `event` is the {@link InputEventKey}.
+     *
+     * ```text
+     *
+     * +-----+ +-----+
+     * | Q   | | Q   | - "Q" - keycode
+     * |   Й | |  ض | - "Й" and "ض" - key_label
+     * +-----+ +-----+
+     *
+     * ```
+     */
+    get keycode(): Key { return _C(this, 5292) as Key; }
+    set keycode(v: Key) { _C(this, 11868, v); }
+
+    /**
+     * Represents the physical location of a key on the 101/102-key US QWERTY keyboard, which corresponds to one of the {@link Key} constants. Physical key codes meant for game input, such as WASD movement, where only the location of the keys is important.
+     * To get a human-readable representation of the {@link InputEventKey}, use {@link OS.getKeycodeString} in combination with {@link DisplayServer.keyboardGetKeycodeFromPhysical} or {@link DisplayServer.keyboardGetLabelFromPhysical}:
+     *
+     *
+     * ```gdscript
+     *
+     * func _input(event):
+     * 	if event is InputEventKey:
+     * 		var keycode = DisplayServer.keyboard_get_keycode_from_physical(event.physical_keycode)
+     * 		var label = DisplayServer.keyboard_get_label_from_physical(event.physical_keycode)
+     * 		print(OS.get_keycode_string(keycode))
+     * 		print(OS.get_keycode_string(label))
+     *
+     * ```
+     */
+    get physicalKeycode(): Key { return _C(this, 5884) as Key; }
+    set physicalKeycode(v: Key) { _C(this, 12307, v); }
+
+    /**
+     * Represents the localized label printed on the key in the current keyboard layout, which corresponds to one of the {@link Key} constants or any valid Unicode character. Key labels are meant for key prompts.
+     * For keyboard layouts with a single label on the key, it is equivalent to {@link keycode}.
+     * To get a human-readable representation of the {@link InputEventKey}, use `OS.get_keycode_string(event.key_label)` where `event` is the {@link InputEventKey}.
+     *
+     * ```text
+     *
+     * +-----+ +-----+
+     * | Q   | | Q   | - "Q" - keycode
+     * |   Й | |  ض | - "Й" and "ض" - key_label
+     * +-----+ +-----+
+     *
+     * ```
+     */
+    get keyLabel(): Key { return _C(this, 5289) as Key; }
+    set keyLabel(v: Key) { _C(this, 11867, v); }
+
+    /**
+     * The key Unicode character code (when relevant), shifted by modifier keys. Unicode character codes for composite characters and complex scripts may not be available unless IME input mode is active. See {@link Window.setImeActive} for more information. Unicode character codes are meant for text input.
+     * **Note:** This property is set by the engine only for a pressed event. If the event is sent by an IME or a virtual keyboard, no corresponding key released event is sent.
+     */
+    get unicode(): number { return _C(this, 6947) as number; }
+    set unicode(v: number) { _C(this, 13169, v); }
+
+    /**
+     * Represents the location of a key which has both left and right versions, such as `Shift` or `Alt`.
+     */
+    get location(): KeyLocation { return _C(this, 5409) as KeyLocation; }
+    set location(v: KeyLocation) { _C(this, 11945, v); }
+
+    /**
+     * If `true`, the key was already pressed before this event. An echo event is a repeated key event sent when the user is holding down the key.
+     * **Note:** The rate at which echo events are sent is typically around 20 events per second (after holding down the key for roughly half a second). However, the key repeat delay/speed can be changed by the user or disabled entirely in the operating system settings. To ensure your project works correctly on all configurations, do not assume the user has a specific key repeat configuration in your project's behavior.
+     */
+    get echo(): boolean { return _C(this, 7914) as boolean; }
+    set echo(v: boolean) { _C(this, 11208, v); }
+
+    static readonly name = _R(354, InputEventKey);
+}

package/gen/classes/InputEventMIDI.ts

@@ -0,0 +1,108 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEvent } from './InputEvent.ts';
+import type { MIDIMessage } from '../global-enums.ts';
+
+/**
+ * InputEventMIDI stores information about messages from [MIDI](https://en.wikipedia.org/wiki/MIDI) (Musical Instrument Digital Interface) devices. These may include musical keyboards, synthesizers, and drum machines.
+ * MIDI messages can be received over a 5-pin MIDI connector or over USB. If your device supports both be sure to check the settings in the device to see which output it is using.
+ * By default, Godot does not detect MIDI devices. You need to call {@link OS.openMidiInputs}, first. You can check which devices are detected with {@link OS.getConnectedMidiInputs}, and close the connection with {@link OS.closeMidiInputs}.
+ *
+ *
+ * ```gdscript
+ *
+ * func _ready():
+ * 	OS.open_midi_inputs()
+ * 	print(OS.get_connected_midi_inputs())
+ *
+ * func _input(input_event):
+ * 	if input_event is InputEventMIDI:
+ * 		_print_midi_info(input_event)
+ *
+ * func _print_midi_info(midi_event):
+ * 	print(midi_event)
+ * 	print("Channel ", midi_event.channel)
+ * 	print("Message ", midi_event.message)
+ * 	print("Pitch ", midi_event.pitch)
+ * 	print("Velocity ", midi_event.velocity)
+ * 	print("Instrument ", midi_event.instrument)
+ * 	print("Pressure ", midi_event.pressure)
+ * 	print("Controller number: ", midi_event.controller_number)
+ * 	print("Controller value: ", midi_event.controller_value)
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** Godot does not support MIDI output, so there is no way to emit MIDI messages from Godot. Only MIDI input is supported.
+ * **Note:** On the Web platform, using MIDI input requires a browser permission to be granted first. This permission request is performed when calling {@link OS.openMidiInputs}. MIDI input will not work until the user accepts the permission request.
+ */
+export class InputEventMIDI extends InputEvent {
+    constructor(name = 355) { super(name); }
+
+    /**
+     * The MIDI channel of this message, ranging from `0` to `15`. MIDI channel `9` is reserved for percussion instruments.
+     */
+    get channel(): number { return _C(this, 4139) as number; }
+    set channel(v: number) { _C(this, 10851, v); }
+
+    /**
+     * Represents the type of MIDI message (see the {@link MIDIMessage} enum).
+     * For more information, see the [MIDI message status byte list chart](https://www.midi.org/specifications-old/item/table-2-expanded-messages-list-status-bytes).
+     */
+    get message(): MIDIMessage { return _C(this, 5518) as MIDIMessage; }
+    set message(v: MIDIMessage) { _C(this, 12030, v); }
+
+    /**
+     * The pitch index number of this MIDI message. This value ranges from `0` to `127`.
+     * On a piano, the **middle C** is `60`, followed by a **C-sharp** (`61`), then a **D** (`62`), and so on. Each octave is split in offsets of 12. See the "MIDI note number" column of the [piano key frequency chart](https://en.wikipedia.org/wiki/Piano_key_frequencies) a full list.
+     */
+    get pitch(): number { return _C(this, 5909) as number; }
+    set pitch(v: number) { _C(this, 12329, v); }
+
+    /**
+     * The velocity of the MIDI message. This value ranges from `0` to `127`. For a musical keyboard, this corresponds to how quickly the key was pressed, and is rarely above `110` in practice.
+     * **Note:** Some MIDI devices may send a {@link MIDI_MESSAGE_NOTE_ON} message with `0` velocity and expect it to be treated the same as a {@link MIDI_MESSAGE_NOTE_OFF} message. If necessary, this can be handled with a few lines of code:
+     *
+     * ```text
+     *
+     * func _input(event):
+     * 	if event is InputEventMIDI:
+     * 		if event.message == MIDI_MESSAGE_NOTE_ON and event.velocity > 0:
+     * 			print("Note pressed!")
+     *
+     * ```
+     */
+    get velocity(): number { return _C(this, 7035) as number; }
+    set velocity(v: number) { _C(this, 13279, v); }
+
+    /**
+     * The instrument (also called *program* or *preset*) used on this MIDI message. This value ranges from `0` to `127`.
+     * To see what each value means, refer to the [General MIDI's instrument list](https://en.wikipedia.org/wiki/General_MIDI#Program_change_events). Keep in mind that the list is off by 1 because it does not begin from 0. A value of `0` corresponds to the acoustic grand piano.
+     */
+    get instrument(): number { return _C(this, 5141) as number; }
+    set instrument(v: number) { _C(this, 11732, v); }
+
+    /**
+     * The strength of the key being pressed. This value ranges from `0` to `127`.
+     * **Note:** For many devices, this value is always `0`. Other devices such as musical keyboards may simulate pressure by changing the {@link velocity}, instead.
+     */
+    get pressure(): number { return _C(this, 5996) as number; }
+    set pressure(v: number) { _C(this, 12406, v); }
+
+    /**
+     * The unique number of the controller, if {@link message} is {@link MIDI_MESSAGE_CONTROL_CHANGE}, otherwise this is `0`. This value can be used to identify sliders for volume, balance, and panning, as well as switches and pedals on the MIDI device. See the [General MIDI specification](https://en.wikipedia.org/wiki/General_MIDI#Controller_events) for a small list.
+     */
+    get controllerNumber(): number { return _C(this, 4320) as number; }
+    set controllerNumber(v: number) { _C(this, 10961, v); }
+
+    /**
+     * The value applied to the controller. If {@link message} is {@link MIDI_MESSAGE_CONTROL_CHANGE}, this value ranges from `0` to `127`, otherwise it is `0`. See also {@link controllerValue}.
+     */
+    get controllerValue(): number { return _C(this, 4321) as number; }
+    set controllerValue(v: number) { _C(this, 10962, v); }
+
+    static readonly name = _R(355, InputEventMIDI);
+}

package/gen/classes/InputEventMagnifyGesture.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventGesture } from './InputEventGesture.ts';
+
+/**
+ * Stores the factor of a magnifying touch gesture. This is usually performed when the user pinches the touch screen and used for zooming in/out.
+ * **Note:** On Android, this requires the {@link ProjectSettings.inputDevices/pointing/android/enablePanAndScaleGestures} project setting to be enabled.
+ */
+export class InputEventMagnifyGesture extends InputEventGesture {
+    constructor(name = 356) { super(name); }
+
+    /**
+     * The amount (or delta) of the event. This value is closer to `1.0` the slower the gesture is performed.
+     */
+    get factor(): number { return _C(this, 4737) as number; }
+    set factor(v: number) { _C(this, 11353, v); }
+
+    static readonly name = _R(356, InputEventMagnifyGesture);
+}

package/gen/classes/InputEventMouse.ts

@@ -0,0 +1,35 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventWithModifiers } from './InputEventWithModifiers.ts';
+import type { MouseButtonMask } from '../global-enums.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * Stores general information about mouse events.
+ */
+export class InputEventMouse extends InputEventWithModifiers {
+
+    /**
+     * The mouse button mask identifier, one of or a bitwise combination of the {@link MouseButton} button masks.
+     */
+    get buttonMask(): MouseButtonMask { return _C(this, 4036) as MouseButtonMask; }
+    set buttonMask(v: MouseButtonMask) { _C(this, 10767, v); }
+
+    /**
+     * When received in {@link Node.Input} or {@link Node.UnhandledInput}, returns the mouse's position in the {@link Viewport} this {@link Node} is in using the coordinate system of this {@link Viewport}.
+     * When received in {@link Control.GuiInput}, returns the mouse's position in the {@link Control} using the local coordinate system of the {@link Control}.
+     */
+    get position(): Vector2 { return _C(this, 5973) as Vector2; }
+    set position(v: Vector2) { _C(this, 12381, v); }
+
+    /**
+     * When received in {@link Node.Input} or {@link Node.UnhandledInput}, returns the mouse's position in the root {@link Viewport} using the coordinate system of the root {@link Viewport}.
+     * When received in {@link Control.GuiInput}, returns the mouse's position in the {@link CanvasLayer} that the {@link Control} is in using the coordinate system of the {@link CanvasLayer}.
+     */
+    get globalPosition(): Vector2 { return _C(this, 4929) as Vector2; }
+    set globalPosition(v: Vector2) { _C(this, 11517, v); }
+
+    static readonly name = _R(357, InputEventMouse);
+}

package/gen/classes/InputEventMouseButton.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventMouse } from './InputEventMouse.ts';
+import type { MouseButton } from '../global-enums.ts';
+
+/**
+ * Stores information about mouse click events. See {@link Node.Input}.
+ * **Note:** On Wear OS devices, rotary input is mapped to {@link MOUSE_BUTTON_WHEEL_UP} and {@link MOUSE_BUTTON_WHEEL_DOWN}. This can be changed to {@link MOUSE_BUTTON_WHEEL_LEFT} and {@link MOUSE_BUTTON_WHEEL_RIGHT} with the {@link ProjectSettings.inputDevices/pointing/android/rotaryInputScrollAxis} setting.
+ */
+export class InputEventMouseButton extends InputEventMouse {
+    constructor(name = 358) { super(name); }
+
+    /**
+     * The amount (or delta) of the event. When used for high-precision scroll events, this indicates the scroll amount (vertical or horizontal). This is only supported on some platforms; the reported sensitivity varies depending on the platform. May be `0` if not supported.
+     */
+    get factor(): number { return _C(this, 4737) as number; }
+    set factor(v: number) { _C(this, 11353, v); }
+
+    /**
+     * The mouse button identifier, one of the {@link MouseButton} button or button wheel constants.
+     */
+    get buttonIndex(): MouseButton { return _C(this, 4035) as MouseButton; }
+    set buttonIndex(v: MouseButton) { _C(this, 10766, v); }
+
+    /**
+     * If `true`, the mouse button event has been canceled.
+     */
+    get canceled(): boolean { return _C(this, 7814) as boolean; }
+    set canceled(v: boolean) { _C(this, 10792, v); }
+
+    /**
+     * If `true`, the mouse button's state is pressed. If `false`, the mouse button's state is released.
+     */
+    get pressed(): boolean { return _C(this, 8199) as boolean; }
+    set pressed(v: boolean) { _C(this, 12404, v); }
+
+    /**
+     * If `true`, the mouse button's state is a double-click.
+     */
+    get doubleClick(): boolean { return _C(this, 7891) as boolean; }
+    set doubleClick(v: boolean) { _C(this, 11156, v); }
+
+    static readonly name = _R(358, InputEventMouseButton);
+}