typescript-to-gdscript 0.1.0

package/typings/classes/InputEventGesture.d.ts

@@ -0,0 +1,11 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for touch gestures. */
+declare class InputEventGesture extends InputEventWithModifiers {
+  /**
+   * <member name="position" type="Vector2" setter="set_position" getter="get_position" default="Vector2(0, 0)">
+   * The local gesture position relative to the {@link Viewport}. If used in {@link Control._gui_input}, the position is relative to the current {@link Control} that received this gesture.
+   */
+  device: int;
+}

package/typings/classes/InputEventJoypadButton.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a gamepad button being pressed or released. */
+declare class InputEventJoypadButton extends InputEvent {
+  /** Button identifier. One of the {@link JoyButton} button constants. */
+  button_index: int;
+  /** If `true`, the button's state is pressed. If `false`, the button's state is released. */
+  pressed: boolean;
+  pressure: float;
+  set_button_index(value: int): void;
+  get_button_index(): int;
+  set_pressed(value: boolean): void;
+  set_pressure(value: float): void;
+  get_pressure(): float;
+}

package/typings/classes/InputEventJoypadMotion.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents axis motions (such as joystick or analog triggers) from a gamepad. */
+declare class InputEventJoypadMotion extends InputEvent {
+  /** Axis identifier. */
+  axis: int;
+  /**
+   * 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.
+   */
+  axis_value: float;
+  set_axis(value: int): void;
+  get_axis(): int;
+  set_axis_value(value: float): void;
+  get_axis_value(): float;
+}

package/typings/classes/InputEventKey.d.ts

@@ -0,0 +1,86 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a key on a keyboard being pressed or released. */
+declare class InputEventKey extends InputEventWithModifiers {
+  /**
+   * 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.
+   */
+  echo: boolean;
+  /**
+   * 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}.
+   * [codeblock lang=text]
+   * +-----+ +-----+
+   * | Q   | | Q   | - "Q" - keycode
+   * |   Й | |  ض | - "Й" and "ض" - key_label
+   * +-----+ +-----+
+   * [/codeblock]
+   */
+  key_label: int;
+  /**
+   * 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}.
+   * [codeblock lang=text]
+   * +-----+ +-----+
+   * | Q   | | Q   | - "Q" - keycode
+   * |   Й | |  ض | - "Й" and "ض" - key_label
+   * +-----+ +-----+
+   * [/codeblock]
+   */
+  keycode: int;
+  /** Represents the location of a key which has both left and right versions, such as `Shift` or `Alt`. */
+  location: int;
+  /**
+   * 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.get_keycode_string} in combination with {@link DisplayServer.keyboard_get_keycode_from_physical} or {@link DisplayServer.keyboard_get_label_from_physical}:
+   */
+  physical_keycode: int;
+  /** If `true`, the key's state is pressed. If `false`, the key's state is released. */
+  pressed: boolean;
+  /**
+   * 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.set_ime_active} 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.
+   */
+  unicode: int;
+  set_echo(value: boolean): void;
+  set_key_label(value: int): void;
+  get_key_label(): int;
+  set_keycode(value: int): void;
+  get_keycode(): int;
+  set_location(value: int): void;
+  get_location(): int;
+  set_physical_keycode(value: int): void;
+  get_physical_keycode(): int;
+  set_pressed(value: boolean): void;
+  set_unicode(value: int): void;
+  get_unicode(): int;
+
+  /** Returns a {@link String} representation of the event's {@link key_label} and modifiers. */
+  as_text_key_label(): string;
+  /** Returns a {@link String} representation of the event's {@link keycode} and modifiers. */
+  as_text_keycode(): 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.
+   */
+  as_text_location(): string;
+  /** Returns a {@link String} representation of the event's {@link physical_keycode} and modifiers. */
+  as_text_physical_keycode(): string;
+  /**
+   * 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}.
+   */
+  get_key_label_with_modifiers(): int;
+  /**
+   * 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}.
+   */
+  get_keycode_with_modifiers(): int;
+  /**
+   * 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}.
+   */
+  get_physical_keycode_with_modifiers(): int;
+}

package/typings/classes/InputEventMIDI.d.ts

@@ -0,0 +1,59 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a MIDI message from a MIDI device, such as a musical keyboard. */
+declare class InputEventMIDI extends InputEvent {
+  /**
+   * The MIDI channel of this message, ranging from `0` to `15`. MIDI channel `9` is reserved for percussion instruments.
+   */
+  channel: int;
+  /**
+   * 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.
+   */
+  controller_number: int;
+  /**
+   * 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 controller_value}.
+   */
+  controller_value: int;
+  /**
+   * 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.
+   */
+  instrument: int;
+  /**
+   * 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).
+   */
+  message: int;
+  /**
+   * 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.
+   */
+  pitch: int;
+  /**
+   * 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.
+   */
+  pressure: int;
+  /**
+   * 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:
+   */
+  velocity: int;
+  set_channel(value: int): void;
+  get_channel(): int;
+  set_controller_number(value: int): void;
+  get_controller_number(): int;
+  set_controller_value(value: int): void;
+  get_controller_value(): int;
+  set_instrument(value: int): void;
+  get_instrument(): int;
+  set_message(value: int): void;
+  get_message(): int;
+  set_pitch(value: int): void;
+  get_pitch(): int;
+  set_pressure(value: int): void;
+  get_pressure(): int;
+  set_velocity(value: int): void;
+  get_velocity(): int;
+}

package/typings/classes/InputEventMagnifyGesture.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a magnifying touch gesture. */
+declare class InputEventMagnifyGesture extends InputEventGesture {
+  /**
+   * The amount (or delta) of the event. This value is closer to `1.0` the slower the gesture is performed.
+   */
+  factor: float;
+  set_factor(value: float): void;
+  get_factor(): float;
+}

package/typings/classes/InputEventMouse.d.ts

@@ -0,0 +1,25 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base input event type for mouse events. */
+declare class InputEventMouse extends InputEventWithModifiers {
+  /**
+   * The mouse button mask identifier, one of or a bitwise combination of the {@link MouseButton} button masks.
+   */
+  button_mask: int;
+  /**
+   * <member name="global_position" type="Vector2" setter="set_global_position" getter="get_global_position" default="Vector2(0, 0)">
+   * When received in {@link Node._input} or {@link Node._unhandled_input}, returns the mouse's position in the root {@link Viewport} using the coordinate system of the root {@link Viewport}.
+   * When received in {@link Control._gui_input}, returns the mouse's position in the {@link CanvasLayer} that the {@link Control} is in using the coordinate system of the {@link CanvasLayer}.
+   */
+  device: int;
+  /**
+   * When received in {@link Node._input} or {@link Node._unhandled_input}, returns the mouse's position in the {@link Viewport} this {@link Node} is in using the coordinate system of this {@link Viewport}.
+   * When received in {@link Control._gui_input}, returns the mouse's position in the {@link Control} using the local coordinate system of the {@link Control}.
+   */
+  position: Vector2;
+  set_button_mask(value: int): void;
+  get_button_mask(): int;
+  set_position(value: Vector2 | Vector2i): void;
+  get_position(): Vector2;
+}

package/typings/classes/InputEventMouseButton.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a mouse button being pressed or released. */
+declare class InputEventMouseButton extends InputEventMouse {
+  /** The mouse button identifier, one of the {@link MouseButton} button or button wheel constants. */
+  button_index: int;
+  /** If `true`, the mouse button event has been canceled. */
+  canceled: boolean;
+  /** If `true`, the mouse button's state is a double-click. */
+  double_click: boolean;
+  /**
+   * 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.
+   */
+  factor: float;
+  /** If `true`, the mouse button's state is pressed. If `false`, the mouse button's state is released. */
+  pressed: boolean;
+  set_button_index(value: int): void;
+  get_button_index(): int;
+  set_canceled(value: boolean): void;
+  set_double_click(value: boolean): void;
+  is_double_click(): boolean;
+  set_factor(value: float): void;
+  get_factor(): float;
+  set_pressed(value: boolean): void;
+}

package/typings/classes/InputEventMouseMotion.d.ts

@@ -0,0 +1,54 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a mouse or a pen movement. */
+declare class InputEventMouseMotion extends InputEventMouse {
+  /**
+   * Returns `true` when using the eraser end of a stylus pen.
+   * **Note:** This property is implemented on Linux, macOS and Windows.
+   */
+  pen_inverted: boolean;
+  /** Represents the pressure the user puts on the pen. Ranges from `0.0` to `1.0`. */
+  pressure: float;
+  /**
+   * The mouse position relative to the previous position (position at the last frame).
+   * **Note:** Since {@link InputEventMouseMotion} may only be emitted when the mouse moves, it is not possible to reliably detect when the mouse has stopped moving by checking this property. A separate, short timer may be necessary.
+   * **Note:** {@link relative} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. This means mouse sensitivity will appear different depending on resolution when using {@link relative} in a script that handles mouse aiming with the {@link Input.MOUSE_MODE_CAPTURED} mouse mode. To avoid this, use {@link screen_relative} instead.
+   */
+  relative: Vector2;
+  /**
+   * The unscaled mouse position relative to the previous position in the coordinate system of the screen (position at the last frame).
+   * **Note:** Since {@link InputEventMouseMotion} may only be emitted when the mouse moves, it is not possible to reliably detect when the mouse has stopped moving by checking this property. A separate, short timer may be necessary.
+   * **Note:** This coordinate is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformed_by}. This should be preferred over {@link relative} for mouse aiming when using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode, regardless of the project's stretch mode.
+   */
+  screen_relative: Vector2;
+  /**
+   * The unscaled mouse velocity in pixels per second in screen coordinates. This velocity is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformed_by}.
+   * **Note:** Use {@link screen_relative} for mouse aiming using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode.
+   */
+  screen_velocity: Vector2;
+  /**
+   * Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from `-1.0` to `1.0` for both axes.
+   */
+  tilt: Vector2;
+  /**
+   * The mouse velocity in pixels per second.
+   * **Note:** {@link velocity} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. That means mouse sensitivity may appear different depending on resolution.
+   * **Note:** Use {@link screen_relative} for mouse aiming using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode.
+   */
+  velocity: Vector2;
+  set_pen_inverted(value: boolean): void;
+  get_pen_inverted(): boolean;
+  set_pressure(value: float): void;
+  get_pressure(): float;
+  set_relative(value: Vector2 | Vector2i): void;
+  get_relative(): Vector2;
+  set_screen_relative(value: Vector2 | Vector2i): void;
+  get_screen_relative(): Vector2;
+  set_screen_velocity(value: Vector2 | Vector2i): void;
+  get_screen_velocity(): Vector2;
+  set_tilt(value: Vector2 | Vector2i): void;
+  get_tilt(): Vector2;
+  set_velocity(value: Vector2 | Vector2i): void;
+  get_velocity(): Vector2;
+}

package/typings/classes/InputEventPanGesture.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a panning touch gesture. */
+declare class InputEventPanGesture extends InputEventGesture {
+  /** Panning amount since last pan event. */
+  delta: Vector2;
+  set_delta(value: Vector2 | Vector2i): void;
+  get_delta(): Vector2;
+}

package/typings/classes/InputEventScreenDrag.d.ts

@@ -0,0 +1,54 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a screen drag event. */
+declare class InputEventScreenDrag extends InputEventFromWindow {
+  /** The drag event index in the case of a multi-drag event. */
+  index: int;
+  /** Returns `true` when using the eraser end of a stylus pen. */
+  pen_inverted: boolean;
+  /** The drag position in the viewport the node is in, using the coordinate system of this viewport. */
+  position: Vector2;
+  /** Represents the pressure the user puts on the pen. Ranges from `0.0` to `1.0`. */
+  pressure: float;
+  /**
+   * The drag position relative to the previous position (position at the last frame).
+   * **Note:** {@link relative} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. This means touch sensitivity will appear different depending on resolution when using {@link relative} in a script that handles touch aiming. To avoid this, use {@link screen_relative} instead.
+   */
+  relative: Vector2;
+  /**
+   * The unscaled drag position relative to the previous position in screen coordinates (position at the last frame). This position is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformed_by}. This should be preferred over {@link relative} for touch aiming regardless of the project's stretch mode.
+   */
+  screen_relative: Vector2;
+  /**
+   * The unscaled drag velocity in pixels per second in screen coordinates. This velocity is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformed_by}. This should be preferred over {@link velocity} for touch aiming regardless of the project's stretch mode.
+   */
+  screen_velocity: Vector2;
+  /**
+   * Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from `-1.0` to `1.0` for both axes.
+   */
+  tilt: Vector2;
+  /**
+   * The drag velocity.
+   * **Note:** {@link velocity} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. This means touch sensitivity will appear different depending on resolution when using {@link velocity} in a script that handles touch aiming. To avoid this, use {@link screen_velocity} instead.
+   */
+  velocity: Vector2;
+  set_index(value: int): void;
+  get_index(): int;
+  set_pen_inverted(value: boolean): void;
+  get_pen_inverted(): boolean;
+  set_position(value: Vector2 | Vector2i): void;
+  get_position(): Vector2;
+  set_pressure(value: float): void;
+  get_pressure(): float;
+  set_relative(value: Vector2 | Vector2i): void;
+  get_relative(): Vector2;
+  set_screen_relative(value: Vector2 | Vector2i): void;
+  get_screen_relative(): Vector2;
+  set_screen_velocity(value: Vector2 | Vector2i): void;
+  get_screen_velocity(): Vector2;
+  set_tilt(value: Vector2 | Vector2i): void;
+  get_tilt(): Vector2;
+  set_velocity(value: Vector2 | Vector2i): void;
+  get_velocity(): Vector2;
+}

package/typings/classes/InputEventScreenTouch.d.ts

@@ -0,0 +1,24 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a screen touch event. */
+declare class InputEventScreenTouch extends InputEventFromWindow {
+  /** If `true`, the touch event has been canceled. */
+  canceled: boolean;
+  /** If `true`, the touch's state is a double tap. */
+  double_tap: boolean;
+  /** The touch index in the case of a multi-touch event. One index = one finger. */
+  index: int;
+  /** The touch position in the viewport the node is in, using the coordinate system of this viewport. */
+  position: Vector2;
+  /** If `true`, the touch's state is pressed. If `false`, the touch's state is released. */
+  pressed: boolean;
+  set_canceled(value: boolean): void;
+  set_double_tap(value: boolean): void;
+  is_double_tap(): boolean;
+  set_index(value: int): void;
+  get_index(): int;
+  set_position(value: Vector2 | Vector2i): void;
+  get_position(): Vector2;
+  set_pressed(value: boolean): void;
+}

package/typings/classes/InputEventShortcut.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a triggered keyboard {@link Shortcut}. */
+declare class InputEventShortcut extends InputEvent {
+  /**
+   * The {@link Shortcut} represented by this event. Its {@link Shortcut.matches_event} method will always return `true` for this event.
+   */
+  shortcut: Shortcut | null;
+  set_shortcut(value: Shortcut | null): void;
+  get_shortcut(): Shortcut | null;
+}

package/typings/classes/InputEventWithModifiers.d.ts

@@ -0,0 +1,37 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for input events affected by modifier keys like `Shift` and `Alt`. */
+declare class InputEventWithModifiers extends InputEventFromWindow {
+  /** State of the `Alt` modifier. */
+  alt_pressed: boolean;
+  /**
+   * Automatically use `Meta` (`Cmd`) on macOS and `Ctrl` on other platforms. If `true`, {@link ctrl_pressed} and {@link meta_pressed} cannot be set.
+   */
+  command_or_control_autoremap: boolean;
+  /** State of the `Ctrl` modifier. */
+  ctrl_pressed: boolean;
+  /**
+   * <member name="meta_pressed" type="bool" setter="set_meta_pressed" getter="is_meta_pressed" default="false">
+   * State of the `Meta` modifier. On Windows and Linux, this represents the Windows key (sometimes called "meta" or "super" on Linux). On macOS, this represents the Command key.
+   */
+  device: int;
+  /** State of the `Shift` modifier. */
+  shift_pressed: boolean;
+  set_alt_pressed(value: boolean): void;
+  is_alt_pressed(): boolean;
+  set_command_or_control_autoremap(value: boolean): void;
+  is_command_or_control_autoremap(): boolean;
+  set_ctrl_pressed(value: boolean): void;
+  is_ctrl_pressed(): boolean;
+  set_shift_pressed(value: boolean): void;
+  is_shift_pressed(): boolean;
+
+  /** Returns the keycode combination of modifier keys. */
+  get_modifiers_mask(): int;
+  /**
+   * On macOS, returns `true` if `Meta` (`Cmd`) is pressed.
+   * On other platforms, returns `true` if `Ctrl` is pressed.
+   */
+  is_command_or_control_pressed(): boolean;
+}

package/typings/classes/InputMap.d.ts

@@ -0,0 +1,50 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A singleton that manages all {@link InputEventAction}s. */
+declare interface InputMap extends GodotObject {
+  /** Adds an {@link InputEvent} to an action. This {@link InputEvent} will trigger the action. */
+  action_add_event(action: string, event: InputEvent): void;
+  /** Removes an {@link InputEvent} from an action. */
+  action_erase_event(action: string, event: InputEvent): void;
+  /** Removes all events from an action. */
+  action_erase_events(action: string): void;
+  /** Returns a deadzone value for the action. */
+  action_get_deadzone(action: string): float;
+  /**
+   * Returns an array of {@link InputEvent}s associated with a given action.
+   * **Note:** When used in the editor (e.g. a tool script or {@link EditorPlugin}), this method will return events for the editor action. If you want to access your project's input binds from the editor, read the `input/*` settings from {@link ProjectSettings}.
+   */
+  action_get_events(action: string): Array<InputEvent>;
+  /** Returns `true` if the action has the given {@link InputEvent} associated with it. */
+  action_has_event(action: string, event: InputEvent): boolean;
+  /** Sets a deadzone value for the action. */
+  action_set_deadzone(action: string, deadzone: float): void;
+  /**
+   * Adds an empty action to the {@link InputMap} with a configurable `deadzone`.
+   * An {@link InputEvent} can then be added to this action with {@link action_add_event}.
+   */
+  add_action(action: string, deadzone?: float): void;
+  /** Removes an action from the {@link InputMap}. */
+  erase_action(action: string): void;
+  /**
+   * Returns `true` if the given event is part of an existing action. This method ignores keyboard modifiers if the given {@link InputEvent} is not pressed (for proper release detection). See {@link action_has_event} if you don't want this behavior.
+   * If `exact_match` is `false`, it ignores additional input modifiers for {@link InputEventKey} and {@link InputEventMouseButton} events, and the direction for {@link InputEventJoypadMotion} events.
+   */
+  event_is_action(event: InputEvent, action: string, exact_match?: boolean): boolean;
+  /** Returns the human-readable description of the given action. */
+  get_action_description(action: string): string;
+  /** Returns an array of all actions in the {@link InputMap}. */
+  get_actions(): Array<string>;
+  /** Returns `true` if the {@link InputMap} has a registered action with the given name. */
+  has_action(action: string): boolean;
+  /**
+   * Clears all {@link InputEventAction} in the {@link InputMap} and load it anew from {@link ProjectSettings}.
+   */
+  load_from_project_settings(): void;
+
+  /** Emitted when the {@link ProjectSettings} {@link InputMap} has been loaded. */
+  project_settings_loaded: Signal<[]>;
+}
+declare const InputMap: InputMap;
+

package/typings/classes/InstancePlaceholder.d.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Placeholder for the root {@link Node} of a {@link PackedScene}. */
+declare class InstancePlaceholder extends Node {
+  /**
+   * Call this method to actually load in the node. The created node will be placed as a sibling *above* the {@link InstancePlaceholder} in the scene tree. The {@link Node}'s reference is also returned for convenience.
+   * **Note:** {@link create_instance} is not thread-safe. Use {@link Object.call_deferred} if calling from a thread.
+   */
+  create_instance(replace?: boolean, custom_scene?: PackedScene): Node | null;
+  /**
+   * Gets the path to the {@link PackedScene} resource file that is loaded by default when calling {@link create_instance}. Not thread-safe. Use {@link Object.call_deferred} if calling from a thread.
+   */
+  get_instance_path(): string;
+  /**
+   * Returns the list of properties that will be applied to the node when {@link create_instance} is called.
+   * If `with_order` is `true`, a key named `.order` (note the leading period) is added to the dictionary. This `.order` key is an {@link Array} of {@link String} property names specifying the order in which properties will be applied (with index 0 being the first).
+   */
+  get_stored_values(with_order?: boolean): Dictionary;
+}

package/typings/classes/IntervalTweener.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Creates an idle interval in a {@link Tween} animation. */
+declare class IntervalTweener extends Tweener {
+}