typescript-to-gdscript 0.1.0

package/typings/classes/EditorSpinSlider.d.ts

@@ -0,0 +1,65 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Godot editor's control for editing numeric values. */
+declare class EditorSpinSlider extends Range {
+  /** The state in which the control used to manipulate the value will be. */
+  control_state: int;
+  /**
+   * If `true`, changing via dragging is applied only at the end of the input (for example, when the user releases a mouse button).
+   */
+  deferred_drag_mode: boolean;
+  /**
+   * If `true`, the {@link EditorSpinSlider} is considered to be editing an integer value. If `false`, the {@link EditorSpinSlider} is considered to be editing a floating-point value. This is used to determine whether a slider should be drawn by default. The slider is only drawn for floats; integers use up-down arrows similar to {@link SpinBox} instead, unless {@link control_state} is set to {@link CONTROL_STATE_PREFER_SLIDER}. It will also use {@link EditorSettings.interface/inspector/integer_drag_speed} instead of {@link EditorSettings.interface/inspector/float_drag_speed} if the slider is available.
+   */
+  editing_integer: boolean;
+  /** If `true`, the slider will not draw background. */
+  flat: boolean;
+  /**
+   * <member name="hide_slider" type="bool" setter="set_hide_slider" getter="is_hiding_slider" default="false" deprecated="Use {@link control_state} instead.">
+   * If `true`, the slider and up/down arrows are hidden.
+   */
+  focus_mode: int;
+  /** The text that displays to the left of the value. */
+  label: string;
+  /** If `true`, the slider can't be interacted with. */
+  read_only: boolean;
+  /**
+   * <member name="step" type="float" setter="set_step" getter="get_step" overrides="Range" default="1.0" />
+   * <member name="suffix" type="String" setter="set_suffix" getter="get_suffix" default="&quot;&quot;">
+   * The suffix to display after the value (in a faded color). This should generally be a plural word. You may have to use an abbreviation if the suffix is too long to be displayed.
+   */
+  size_flags_vertical: int;
+  set_control_state(value: int): void;
+  get_control_state(): int;
+  set_deferred_drag_mode_enabled(value: boolean): void;
+  is_deferred_drag_mode_enabled(): boolean;
+  set_editing_integer(value: boolean): void;
+  is_editing_integer(): boolean;
+  set_flat(value: boolean): void;
+  is_flat(): boolean;
+  set_label(value: string | NodePath): void;
+  get_label(): string;
+  set_read_only(value: boolean): void;
+
+  /** Emitted when the spinner/slider is grabbed. */
+  grabbed: Signal<[]>;
+  /** Emitted when the spinner/slider is ungrabbed. */
+  ungrabbed: Signal<[]>;
+  /** Emitted when the updown button is pressed. */
+  updown_pressed: Signal<[]>;
+  /** Emitted when the value form gains focus. */
+  value_focus_entered: Signal<[]>;
+  /** Emitted when the value form loses focus. */
+  value_focus_exited: Signal<[]>;
+
+  // enum ControlState
+  /**
+   * The type of control used will depend on the value of {@link editing_integer}. Up-down arrows if `true`, a slider if `false`.
+   */
+  static readonly CONTROL_STATE_DEFAULT: int;
+  /** A slider will always be used, even if {@link editing_integer} is enabled. */
+  static readonly CONTROL_STATE_PREFER_SLIDER: int;
+  /** Neither the up-down arrows nor the slider will be shown. */
+  static readonly CONTROL_STATE_HIDE: int;
+}

package/typings/classes/EditorSyntaxHighlighter.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for {@link SyntaxHighlighter} used by the {@link ScriptEditor}. */
+declare class EditorSyntaxHighlighter extends SyntaxHighlighter {
+  /** Virtual method which creates a new instance of the syntax highlighter. */
+  _create(): EditorSyntaxHighlighter | null;
+  /** Virtual method which can be overridden to return the syntax highlighter name. */
+  _get_name(): string;
+  /** Virtual method which can be overridden to return the supported language names. */
+  _get_supported_languages(): PackedStringArray;
+}

package/typings/classes/EditorToaster.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Manages toast notifications within the editor. */
+declare class EditorToaster extends HBoxContainer {
+  /** Pushes a toast notification to the editor for display. */
+  push_toast(message: string | NodePath, severity: int, tooltip?: string | NodePath): void;
+
+  // enum Severity
+  /** Toast will display with an INFO severity. */
+  static readonly SEVERITY_INFO: int;
+  /** Toast will display with a WARNING severity and have a corresponding color. */
+  static readonly SEVERITY_WARNING: int;
+  /** Toast will display with an ERROR severity and have a corresponding color. */
+  static readonly SEVERITY_ERROR: int;
+}

package/typings/classes/EditorTranslationParserPlugin.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Plugin for adding custom parsers to extract strings that are to be translated from custom files (.csv, .json etc.).
+ */
+declare class EditorTranslationParserPlugin extends RefCounted {
+  /** Gets the list of file extensions to associate with this parser, e.g. `["csv"]`. */
+  _get_recognized_extensions(): PackedStringArray;
+  /** Override this method to define a custom parsing logic to extract the translatable strings. */
+  _parse_file(path: string | NodePath): Array<PackedStringArray>;
+}

package/typings/classes/EditorUndoRedoManager.d.ts

@@ -0,0 +1,86 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Manages undo history of scenes opened in the editor. */
+declare class EditorUndoRedoManager extends GodotObject {
+  /**
+   * Register a method that will be called when the action is committed (i.e. the "do" action).
+   * If this is the first operation, the `object` will be used to deduce target undo history.
+   */
+  add_do_method(object: GodotObject, method: string, ...args: any[]): void;
+  /**
+   * Register a property value change for "do".
+   * If this is the first operation, the `object` will be used to deduce target undo history.
+   */
+  add_do_property(object: GodotObject, property: string, value: unknown): void;
+  /**
+   * Register a reference for "do" that will be erased if the "do" history is lost. This is useful mostly for new nodes created for the "do" call. Do not use for resources.
+   */
+  add_do_reference(object: GodotObject): void;
+  /**
+   * Register a method that will be called when the action is undone (i.e. the "undo" action).
+   * If this is the first operation, the `object` will be used to deduce target undo history.
+   */
+  add_undo_method(object: GodotObject, method: string, ...args: any[]): void;
+  /**
+   * Register a property value change for "undo".
+   * If this is the first operation, the `object` will be used to deduce target undo history.
+   */
+  add_undo_property(object: GodotObject, property: string, value: unknown): void;
+  /**
+   * Register a reference for "undo" that will be erased if the "undo" history is lost. This is useful mostly for nodes removed with the "do" call (not the "undo" call!).
+   */
+  add_undo_reference(object: GodotObject): void;
+  /**
+   * Clears the given undo history. You can clear history for a specific scene, global history, or for all histories at once (except {@link REMOTE_HISTORY}) if `id` is {@link INVALID_HISTORY}.
+   * If `increase_version` is `true`, the undo history version will be increased, marking it as unsaved. Useful for operations that modify the scene, but don't support undo.
+   * **Note:** If you want to mark an edited scene as unsaved without clearing its history, use {@link EditorInterface.mark_scene_as_unsaved} instead.
+   */
+  clear_history(id?: int, increase_version?: boolean): void;
+  /**
+   * Commits the action. If `execute` is `true` (default), all "do" methods/properties are called/set when this function is called.
+   */
+  commit_action(execute?: boolean): void;
+  /**
+   * Create a new action. After this is called, do all your calls to {@link add_do_method}, {@link add_undo_method}, {@link add_do_property}, and {@link add_undo_property}, then commit the action with {@link commit_action}.
+   * The way actions are merged is dictated by the `merge_mode` argument.
+   * If `custom_context` object is provided, it will be used for deducing target history (instead of using the first operation).
+   * The way undo operation are ordered in actions is dictated by `backward_undo_ops`. When `backward_undo_ops` is `false` undo option are ordered in the same order they were added. Which means the first operation to be added will be the first to be undone.
+   * If `mark_unsaved` is `false`, the action will not mark the history as unsaved. This is useful for example for actions that change a selection, or a setting that will be saved automatically. Otherwise, this should be left to `true` if the action requires saving by the user or if it can cause data loss when left unsaved.
+   */
+  create_action(name: string | NodePath, merge_mode: int, custom_context?: GodotObject, backward_undo_ops?: boolean, mark_unsaved?: boolean): void;
+  /**
+   * Forces the next operation (e.g. {@link add_do_method}) to use the action's history rather than guessing it from the object. This is sometimes needed when a history can't be correctly determined, like for a nested resource that doesn't have a path yet.
+   * This method should only be used when absolutely necessary, otherwise it might cause invalid history state. For most of complex cases, the `custom_context` parameter of {@link create_action} is sufficient.
+   */
+  force_fixed_history(): void;
+  /**
+   * Returns the {@link UndoRedo} object associated with the given history `id`.
+   * `id` above `0` are mapped to the opened scene tabs (but it doesn't match their order). `id` of `0` or lower have special meaning (see {@link SpecialHistory}).
+   * Best used with {@link get_object_history_id}. This method is only provided in case you need some more advanced methods of {@link UndoRedo} (but keep in mind that directly operating on the {@link UndoRedo} object might affect editor's stability).
+   */
+  get_history_undo_redo(id: int): UndoRedo | null;
+  /**
+   * Returns the history ID deduced from the given `object`. It can be used with {@link get_history_undo_redo}.
+   */
+  get_object_history_id(object: GodotObject): int;
+  /**
+   * Returns `true` if the {@link EditorUndoRedoManager} is currently committing the action, i.e. running its "do" method or property change (see {@link commit_action}).
+   */
+  is_committing_action(): boolean;
+
+  /**
+   * Emitted when the list of actions in any history has changed, either when an action is committed or a history is cleared.
+   */
+  history_changed: Signal<[]>;
+  /** Emitted when the version of any history has changed as a result of undo or redo call. */
+  version_changed: Signal<[]>;
+
+  // enum SpecialHistory
+  /** Global history not associated with any scene, but with external resources etc. */
+  static readonly GLOBAL_HISTORY: int;
+  /** History associated with remote inspector. Used when live editing a running project. */
+  static readonly REMOTE_HISTORY: int;
+  /** Invalid "null" history. It's a special value, not associated with any object. */
+  static readonly INVALID_HISTORY: int;
+}

package/typings/classes/EditorVCSInterface.d.ts

@@ -0,0 +1,121 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Version Control System (VCS) interface, which reads and writes to the local VCS in use. */
+declare class EditorVCSInterface extends GodotObject {
+  /** Checks out a `branch_name` in the VCS. */
+  _checkout_branch(branch_name: string | NodePath): boolean;
+  /** Commits the currently staged changes and applies the commit `msg` to the resulting commit. */
+  _commit(msg: string | NodePath): void;
+  /** Creates a new branch named `branch_name` in the VCS. */
+  _create_branch(branch_name: string | NodePath): void;
+  /**
+   * Creates a new remote destination with name `remote_name` and points it to `remote_url`. This can be an HTTPS remote or an SSH remote.
+   */
+  _create_remote(remote_name: string | NodePath, remote_url: string | NodePath): void;
+  /** Discards the changes made in a file present at `file_path`. */
+  _discard_file(file_path: string | NodePath): void;
+  /**
+   * Fetches new changes from the `remote`, but doesn't write changes to the current working directory. Equivalent to `git fetch`.
+   */
+  _fetch(remote: string | NodePath): void;
+  /**
+   * Gets an instance of an {@link Array} of {@link String}s containing available branch names in the VCS.
+   */
+  _get_branch_list(): Array<string>;
+  /** Gets the current branch name defined in the VCS. */
+  _get_current_branch_name(): string;
+  /**
+   * Returns an array of {@link Dictionary} items (see {@link create_diff_file}, {@link create_diff_hunk}, {@link create_diff_line}, {@link add_line_diffs_into_diff_hunk} and {@link add_diff_hunks_into_diff_file}), each containing information about a diff. If `identifier` is a file path, returns a file diff, and if it is a commit identifier, then returns a commit diff.
+   */
+  _get_diff(identifier: string | NodePath, area: int): Array<Dictionary>;
+  /**
+   * Returns an {@link Array} of {@link Dictionary} items (see {@link create_diff_hunk}), each containing a line diff between a file at `file_path` and the `text` which is passed in.
+   */
+  _get_line_diff(file_path: string | NodePath, text: string | NodePath): Array<Dictionary>;
+  /**
+   * Returns an {@link Array} of {@link Dictionary} items (see {@link create_status_file}), each containing the status data of every modified file in the project folder.
+   */
+  _get_modified_files_data(): Array<Dictionary>;
+  /**
+   * Returns an {@link Array} of {@link Dictionary} items (see {@link create_commit}), each containing the data for a past commit.
+   */
+  _get_previous_commits(max_commits: int): Array<Dictionary>;
+  /**
+   * Returns an {@link Array} of {@link String}s, each containing the name of a remote configured in the VCS.
+   */
+  _get_remotes(): Array<string>;
+  /** Returns the name of the underlying VCS provider. */
+  _get_vcs_name(): string;
+  /**
+   * Initializes the VCS plugin when called from the editor. Returns whether or not the plugin was successfully initialized. A VCS project is initialized at `project_path`.
+   */
+  _initialize(project_path: string | NodePath): boolean;
+  /** Pulls changes from the remote. This can give rise to merge conflicts. */
+  _pull(remote: string | NodePath): void;
+  /**
+   * Pushes changes to the `remote`. If `force` is `true`, a force push will override the change history already present on the remote.
+   */
+  _push(remote: string | NodePath, force: boolean): void;
+  /** Remove a branch from the local VCS. */
+  _remove_branch(branch_name: string | NodePath): void;
+  /** Remove a remote from the local VCS. */
+  _remove_remote(remote_name: string | NodePath): void;
+  /**
+   * Set user credentials in the underlying VCS. `username` and `password` are used only during HTTPS authentication unless not already mentioned in the remote URL. `ssh_public_key_path`, `ssh_private_key_path`, and `ssh_passphrase` are only used during SSH authentication.
+   */
+  _set_credentials(username: string | NodePath, password: string | NodePath, ssh_public_key_path: string | NodePath, ssh_private_key_path: string | NodePath, ssh_passphrase: string | NodePath): void;
+  /**
+   * Shuts down VCS plugin instance. Called when the user either closes the editor or shuts down the VCS plugin through the editor UI.
+   */
+  _shut_down(): boolean;
+  /** Stages the file present at `file_path` to the staged area. */
+  _stage_file(file_path: string | NodePath): void;
+  /** Unstages the file present at `file_path` from the staged area to the unstaged area. */
+  _unstage_file(file_path: string | NodePath): void;
+  /** Helper function to add an array of `diff_hunks` into a `diff_file`. */
+  add_diff_hunks_into_diff_file(diff_file: Dictionary, diff_hunks: Array<Dictionary>): Dictionary;
+  /** Helper function to add an array of `line_diffs` into a `diff_hunk`. */
+  add_line_diffs_into_diff_hunk(diff_hunk: Dictionary, line_diffs: Array<Dictionary>): Dictionary;
+  /**
+   * Helper function to create a commit {@link Dictionary} item. `msg` is the commit message of the commit. `author` is a single human-readable string containing all the author's details, e.g. the email and name configured in the VCS. `id` is the identifier of the commit, in whichever format your VCS may provide an identifier to commits. `unix_timestamp` is the UTC Unix timestamp of when the commit was created. `offset_minutes` is the timezone offset in minutes, recorded from the system timezone where the commit was created.
+   */
+  create_commit(msg: string | NodePath, author: string | NodePath, id: string | NodePath, unix_timestamp: int, offset_minutes: int): Dictionary;
+  /** Helper function to create a {@link Dictionary} for storing old and new diff file paths. */
+  create_diff_file(new_file: string | NodePath, old_file: string | NodePath): Dictionary;
+  /**
+   * Helper function to create a {@link Dictionary} for storing diff hunk data. `old_start` is the starting line number in old file. `new_start` is the starting line number in new file. `old_lines` is the number of lines in the old file. `new_lines` is the number of lines in the new file.
+   */
+  create_diff_hunk(old_start: int, new_start: int, old_lines: int, new_lines: int): Dictionary;
+  /**
+   * Helper function to create a {@link Dictionary} for storing a line diff. `new_line_no` is the line number in the new file (can be `-1` if the line is deleted). `old_line_no` is the line number in the old file (can be `-1` if the line is added). `content` is the diff text. `status` is a single character string which stores the line origin.
+   */
+  create_diff_line(new_line_no: int, old_line_no: int, content: string | NodePath, status: string | NodePath): Dictionary;
+  /** Helper function to create a {@link Dictionary} used by editor to read the status of a file. */
+  create_status_file(file_path: string | NodePath, change_type: int, area: int): Dictionary;
+  /**
+   * Pops up an error message in the editor which is shown as coming from the underlying VCS. Use this to show VCS specific error messages.
+   */
+  popup_error(msg: string | NodePath): void;
+
+  // enum ChangeType
+  /** A new file has been added. */
+  static readonly CHANGE_TYPE_NEW: int;
+  /** An earlier added file has been modified. */
+  static readonly CHANGE_TYPE_MODIFIED: int;
+  /** An earlier added file has been renamed. */
+  static readonly CHANGE_TYPE_RENAMED: int;
+  /** An earlier added file has been deleted. */
+  static readonly CHANGE_TYPE_DELETED: int;
+  /** An earlier added file has been typechanged. */
+  static readonly CHANGE_TYPE_TYPECHANGE: int;
+  /** A file is left unmerged. */
+  static readonly CHANGE_TYPE_UNMERGED: int;
+  // enum TreeArea
+  /** A commit is encountered from the commit area. */
+  static readonly TREE_AREA_COMMIT: int;
+  /** A file is encountered from the staged area. */
+  static readonly TREE_AREA_STAGED: int;
+  /** A file is encountered from the unstaged area. */
+  static readonly TREE_AREA_UNSTAGED: int;
+}

package/typings/classes/EncodedObjectAsID.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Holds a reference to an {@link Object}'s instance ID. */
+declare class EncodedObjectAsID extends RefCounted {
+  /**
+   * The {@link Object} identifier stored in this {@link EncodedObjectAsID} instance. The object instance can be retrieved with {@link @GlobalScope.instance_from_id}.
+   */
+  object_id: int;
+  set_object_id(value: int): void;
+  get_object_id(): int;
+}

package/typings/classes/Engine.d.ts

@@ -0,0 +1,202 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides access to engine properties. */
+declare interface Engine extends GodotObject {
+  /**
+   * The maximum number of frames that can be rendered every second (FPS). A value of `0` means the framerate is uncapped.
+   * Limiting the FPS can be useful to reduce the host machine's power consumption, which reduces heat, noise emissions, and improves battery life.
+   * If {@link ProjectSettings.display/window/vsync/vsync_mode} is **Enabled** or **Adaptive**, the setting takes precedence and the max FPS number cannot exceed the monitor's refresh rate. See also {@link DisplayServer.screen_get_refresh_rate}.
+   * If {@link ProjectSettings.display/window/vsync/vsync_mode} is **Enabled**, on monitors with variable refresh rate enabled (G-Sync/FreeSync), using an FPS limit a few frames lower than the monitor's refresh rate will reduce input lag while avoiding tearing (https://blurbusters.com/howto-low-lag-vsync-on/). At higher refresh rates, the difference between the FPS limit and the monitor refresh rate should be increased to ensure frames to account for timing inaccuracies. The optimal formula for the FPS limit value in this scenario is `r - (r * r) / 3600.0`, where `r` is the monitor's refresh rate.
+   * **Note:** The actual number of frames per second may still be below this value if the CPU or GPU cannot keep up with the project's logic and rendering.
+   * **Note:** If {@link ProjectSettings.display/window/vsync/vsync_mode} is **Disabled**, limiting the FPS to a high value that can be consistently reached on the system can reduce input lag compared to an uncapped framerate. Since this works by ensuring the GPU load is lower than 100%, this latency reduction is only effective in GPU-bottlenecked scenarios, not CPU-bottlenecked scenarios.
+   */
+  max_fps: int;
+  /**
+   * The maximum number of physics steps that can be simulated each rendered frame.
+   * **Note:** The default value is tuned to prevent expensive physics simulations from triggering even more expensive simulations indefinitely. However, the game will appear to slow down if the rendering FPS is less than `1 / max_physics_steps_per_frame` of {@link physics_ticks_per_second}. This occurs even if `delta` is consistently used in physics calculations. To avoid this, increase {@link max_physics_steps_per_frame} if you have increased {@link physics_ticks_per_second} significantly above its default value.
+   */
+  max_physics_steps_per_frame: int;
+  /**
+   * How much physics ticks are synchronized with real time. If `0` or less, the ticks are fully synchronized. Higher values cause the in-game clock to deviate more from the real clock, but they smooth out framerate jitters.
+   * **Note:** The default value of `0.5` should be good enough for most cases; values above `2` could cause the game to react to dropped frames with a noticeable delay and are not recommended.
+   * **Note:** When using a custom physics interpolation solution, or within a network game, it's recommended to disable the physics jitter fix by setting this property to `0`.
+   */
+  physics_jitter_fix: float;
+  /**
+   * The number of fixed iterations per second. This controls how often physics simulation and the {@link Node._physics_process} method are run.
+   * CPU usage scales approximately with the physics tick rate. However, at very low tick rates (usually below 30), physics behavior can break down. Input can also become less responsive at low tick rates as there can be a gap between input being registered, and the response on the next physics tick. High tick rates give more accurate physics simulation, particularly for fast moving objects. For example, racing games may benefit from increasing the tick rate above the default 60.
+   * See also {@link max_fps} and {@link ProjectSettings.physics/common/physics_ticks_per_second}.
+   * **Note:** Only {@link max_physics_steps_per_frame} physics ticks may be simulated per rendered frame at most. If more physics ticks have to be simulated per rendered frame to keep up with rendering, the project will appear to slow down (even if `delta` is used consistently in physics calculations). Therefore, it is recommended to also increase {@link max_physics_steps_per_frame} if increasing {@link physics_ticks_per_second} significantly above its default value.
+   * **Note:** Consider enabling physics interpolation ($DOCS_URL/tutorials/physics/interpolation/index.html) if you change {@link physics_ticks_per_second} to a value that is not a multiple of `60`. Using physics interpolation will avoid jittering when the monitor refresh rate and physics update rate don't exactly match.
+   */
+  physics_ticks_per_second: int;
+  /**
+   * If `false`, stops printing error and warning messages to the console and editor Output log. This can be used to hide error and warning messages during unit test suite runs. This property is equivalent to the {@link ProjectSettings.application/run/disable_stderr} project setting.
+   * **Note:** This property does not impact the editor's Errors tab when running a project from the editor.
+   * **Warning:** If set to `false` anywhere in the project, important error messages may be hidden even if they are emitted from other scripts. In a `@tool` script, this will also impact the editor itself. Do *not* report bugs before ensuring error messages are enabled (as they are by default).
+   */
+  print_error_messages: boolean;
+  /**
+   * If `false`, stops printing messages (for example using {@link @GlobalScope.print}) to the console, log files, and editor Output log. This property is equivalent to the {@link ProjectSettings.application/run/disable_stdout} project setting.
+   * **Note:** This does not stop printing errors or warnings produced by scripts to the console or log files, for more details see {@link print_error_messages}.
+   */
+  print_to_stdout: boolean;
+  /**
+   * The speed multiplier at which the in-game clock updates, compared to real time. For example, if set to `2.0` the game runs twice as fast, and if set to `0.5` the game runs half as fast.
+   * This value affects {@link Timer}, {@link SceneTreeTimer}, and all other simulations that make use of `delta` time (such as {@link Node._process} and {@link Node._physics_process}).
+   * **Note:** It's recommended to keep this property above `0.0`, as the game may behave unexpectedly otherwise.
+   * **Note:** This does not affect audio playback speed. Use {@link AudioServer.playback_speed_scale} to adjust audio playback speed independently of {@link Engine.time_scale}.
+   * **Note:** This does not automatically adjust {@link physics_ticks_per_second}. With values above `1.0` physics simulation may become less precise, as each physics tick will stretch over a larger period of engine time. If you're modifying {@link Engine.time_scale} to speed up simulation by a large factor, consider also increasing {@link physics_ticks_per_second} to make the simulation more reliable.
+   */
+  time_scale: float;
+  set_max_fps(value: int): void;
+  get_max_fps(): int;
+  set_max_physics_steps_per_frame(value: int): void;
+  get_max_physics_steps_per_frame(): int;
+  set_physics_jitter_fix(value: float): void;
+  get_physics_jitter_fix(): float;
+  set_physics_ticks_per_second(value: int): void;
+  get_physics_ticks_per_second(): int;
+  set_print_error_messages(value: boolean): void;
+  is_printing_error_messages(): boolean;
+  set_print_to_stdout(value: boolean): void;
+  is_printing_to_stdout(): boolean;
+  set_time_scale(value: float): void;
+  get_time_scale(): float;
+
+  /**
+   * Captures and returns backtraces from all registered script languages.
+   * By default, the returned {@link ScriptBacktrace} will only contain stack frames in editor builds and debug builds. To enable them for release builds as well, you need to enable {@link ProjectSettings.debug/settings/gdscript/always_track_call_stacks}.
+   * If `include_variables` is `true`, the backtrace will also include the names and values of any global variables (e.g. autoload singletons) at the point of the capture, as well as local variables and class member variables at each stack frame. This will however will only be respected when running the game with a debugger attached, like when running the game from the editor. To enable it for export builds as well, you need to enable {@link ProjectSettings.debug/settings/gdscript/always_track_local_variables}.
+   * **Warning:** When `include_variables` is `true`, any captured variables can potentially (e.g. with GDScript backtraces) be their actual values, including any object references. This means that storing such a {@link ScriptBacktrace} will prevent those objects from being deallocated, so it's generally recommended not to do so.
+   */
+  capture_script_backtraces(include_variables?: boolean): Array<ScriptBacktrace>;
+  /**
+   * Returns the name of the CPU architecture the Godot binary was built for. Possible return values include `"x86_64"`, `"x86_32"`, `"arm64"`, `"arm32"`, `"rv64"`, `"ppc64"`, `"loongarch64"`, `"wasm64"`, and `"wasm32"`.
+   * To detect whether the current build is 64-bit, or the type of architecture, don't use the architecture name. Instead, use {@link OS.has_feature} to check for the `"64"` feature tag, or tags such as `"x86"` or `"arm"`. See the Feature Tags ($DOCS_URL/tutorials/export/feature_tags.html) documentation for more details.
+   * **Note:** This method does *not* return the name of the system's CPU architecture (like {@link OS.get_processor_name}). For example, when running an `x86_32` Godot binary on an `x86_64` system, the returned value will still be `"x86_32"`.
+   */
+  get_architecture_name(): string;
+  /**
+   * Returns the engine author information as a {@link Dictionary}, where each entry is an {@link Array} of strings with the names of notable contributors to the Godot Engine: `lead_developers`, `founders`, `project_managers`, and `developers`.
+   */
+  get_author_info(): Dictionary;
+  /**
+   * Returns an {@link Array} of dictionaries with copyright information for every component of Godot's source code.
+   * Every {@link Dictionary} contains a `name` identifier, and a `parts` array of dictionaries. It describes the component in detail with the following entries:
+   * - `files` - {@link Array} of file paths from the source code affected by this component;
+   * - `copyright` - {@link Array} of owners of this component;
+   * - `license` - The license applied to this component (such as "Expat (https://en.wikipedia.org/wiki/MIT_License#Ambiguity_and_variants)" or "CC-BY-4.0 (https://creativecommons.org/licenses/by/4.0/)").
+   */
+  get_copyright_info(): Array<Dictionary>;
+  /**
+   * Returns a {@link Dictionary} of categorized donor names. Each entry is an {@link Array} of strings:
+   * {`platinum_sponsors`, `gold_sponsors`, `silver_sponsors`, `bronze_sponsors`, `mini_sponsors`, `gold_donors`, `silver_donors`, `bronze_donors`}
+   */
+  get_donor_info(): Dictionary;
+  /**
+   * Returns the total number of frames drawn since the engine started.
+   * **Note:** On headless platforms, or if rendering is disabled with `--disable-render-loop` via command line, this method always returns `0`. See also {@link get_process_frames}.
+   */
+  get_frames_drawn(): int;
+  /** Returns the average frames rendered every second (FPS), also known as the framerate. */
+  get_frames_per_second(): float;
+  /**
+   * Returns a {@link Dictionary} of licenses used by Godot and included third party components. Each entry is a license name (such as "Expat (https://en.wikipedia.org/wiki/MIT_License#Ambiguity_and_variants)") and its associated text.
+   */
+  get_license_info(): Dictionary;
+  /** Returns the full Godot license text. */
+  get_license_text(): string;
+  /**
+   * Returns the instance of the {@link MainLoop}. This is usually the main {@link SceneTree} and is the same as {@link Node.get_tree}.
+   * **Note:** The type instantiated as the main loop can changed with {@link ProjectSettings.application/run/main_loop_type}.
+   */
+  get_main_loop(): MainLoop | null;
+  /**
+   * Returns the total number of frames passed since the engine started. This number is increased every **physics frame**. See also {@link get_process_frames}.
+   * This method can be used to run expensive logic less often without relying on a {@link Timer}:
+   */
+  get_physics_frames(): int;
+  /**
+   * Returns the fraction through the current physics tick we are at the time of rendering the frame. This can be used to implement fixed timestep interpolation.
+   */
+  get_physics_interpolation_fraction(): float;
+  /**
+   * Returns the total number of frames passed since the engine started. This number is increased every **process frame**, regardless of whether the render loop is enabled. See also {@link get_frames_drawn} and {@link get_physics_frames}.
+   * This method can be used to run expensive logic less often without relying on a {@link Timer}:
+   */
+  get_process_frames(): int;
+  /** Returns an instance of a {@link ScriptLanguage} with the given `index`. */
+  get_script_language(index: int): ScriptLanguage | null;
+  /** Returns the number of available script languages. Use with {@link get_script_language}. */
+  get_script_language_count(): int;
+  /**
+   * Returns the global singleton with the given `name`, or `null` if it does not exist. Often used for plugins. See also {@link has_singleton} and {@link get_singleton_list}.
+   * **Note:** Global singletons are not the same as autoloaded nodes, which are configurable in the project settings.
+   */
+  get_singleton(name: string): GodotObject | null;
+  /** Returns a list of names of all available global singletons. See also {@link get_singleton}. */
+  get_singleton_list(): PackedStringArray;
+  /**
+   * Returns the current engine version information as a {@link Dictionary} containing the following entries:
+   * - `major` - Major version number as an int;
+   * - `minor` - Minor version number as an int;
+   * - `patch` - Patch version number as an int;
+   * - `hex` - Full version encoded as a hexadecimal int with one byte (2 hex digits) per number (see example below);
+   * - `status` - Status (such as "beta", "rc1", "rc2", "stable", etc.) as a String;
+   * - `build` - Build name (e.g. "custom_build") as a String;
+   * - `hash` - Full Git commit hash as a String;
+   * - `timestamp` - Holds the Git commit date UNIX timestamp in seconds as an int, or `0` if unavailable;
+   * - `string` - `major`, `minor`, `patch`, `status`, and `build` in a single String.
+   * The `hex` value is encoded as follows, from left to right: one byte for the major, one byte for the minor, one byte for the patch version. For example, "3.1.12" would be `0x03010C`.
+   * **Note:** The `hex` value is still an [int] internally, and printing it will give you its decimal representation, which is not particularly meaningful. Use hexadecimal literals for quick version comparisons from code:
+   */
+  get_version_info(): Dictionary;
+  /**
+   * Returns the path to the {@link MovieWriter}'s output file, or an empty string if the engine wasn't started in Movie Maker mode. The default path can be changed in {@link ProjectSettings.editor/movie_writer/movie_file}.
+   */
+  get_write_movie_path(): string;
+  /**
+   * Returns `true` if a singleton with the given `name` exists in the global scope. See also {@link get_singleton}.
+   * **Note:** Global singletons are not the same as autoloaded nodes, which are configurable in the project settings.
+   */
+  has_singleton(name: string): boolean;
+  /**
+   * Returns `true` if the script is currently running inside the editor, otherwise returns `false`. This is useful for `@tool` scripts to conditionally draw editor helpers, or prevent accidentally running "game" code that would affect the scene state while in the editor:
+   * See Running code in the editor ($DOCS_URL/tutorials/plugins/running_code_in_the_editor.html) in the documentation for more information.
+   * **Note:** To detect whether the script is running on an editor *build* (such as when pressing `F5`), use {@link OS.has_feature} with the `"editor"` argument instead. `OS.has_feature("editor")` evaluate to `true` both when the script is running in the editor and when running the project from the editor, but returns `false` when run from an exported project.
+   */
+  is_editor_hint(): boolean;
+  /**
+   * Returns `true` if the engine is running embedded in the editor. This is useful to prevent attempting to update window mode or window flags that are not supported when running the project embedded in the editor.
+   */
+  is_embedded_in_editor(): boolean;
+  /** Returns `true` if the engine is inside the fixed physics process step of the main loop. */
+  is_in_physics_frame(): boolean;
+  /**
+   * Registers a {@link ScriptLanguage} instance to be available with `ScriptServer`.
+   * Returns:
+   * - {@link OK} on success;
+   * - {@link ERR_UNAVAILABLE} if `ScriptServer` has reached the limit and cannot register any new language;
+   * - {@link ERR_ALREADY_EXISTS} if `ScriptServer` already contains a language with similar extension/name/type.
+   */
+  register_script_language(language: ScriptLanguage): int;
+  /**
+   * Registers the given {@link Object} `instance` as a singleton, available globally under `name`. Useful for plugins.
+   */
+  register_singleton(name: string, instance: GodotObject): void;
+  /**
+   * Unregisters the {@link ScriptLanguage} instance from `ScriptServer`.
+   * Returns:
+   * - {@link OK} on success;
+   * - {@link ERR_DOES_NOT_EXIST} if the language is not registered in `ScriptServer`.
+   */
+  unregister_script_language(language: ScriptLanguage): int;
+  /**
+   * Removes the singleton registered under `name`. The singleton object is *not* freed. Only works with user-defined singletons registered with {@link register_singleton}.
+   */
+  unregister_singleton(name: string): void;
+}
+declare const Engine: Engine;
+

package/typings/classes/EngineDebugger.d.ts

@@ -0,0 +1,66 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Exposes the internal debugger. */
+declare interface EngineDebugger extends GodotObject {
+  /** Clears all breakpoints. */
+  clear_breakpoints(): void;
+  /**
+   * Starts a debug break in script execution, optionally specifying whether the program can continue based on `can_continue` and whether the break was due to a breakpoint.
+   */
+  debug(can_continue?: boolean, is_error_breakpoint?: boolean): void;
+  /** Returns the current debug depth. */
+  get_depth(): int;
+  /** Returns the number of lines that remain. */
+  get_lines_left(): int;
+  /** Returns `true` if a capture with the given name is present otherwise `false`. */
+  has_capture(name: string): boolean;
+  /** Returns `true` if a profiler with the given name is present otherwise `false`. */
+  has_profiler(name: string): boolean;
+  /** Inserts a new breakpoint with the given `source` and `line`. */
+  insert_breakpoint(line: int, source: string): void;
+  /** Returns `true` if the debugger is active otherwise `false`. */
+  is_active(): boolean;
+  /** Returns `true` if the given `source` and `line` represent an existing breakpoint. */
+  is_breakpoint(line: int, source: string): boolean;
+  /** Returns `true` if a profiler with the given name is present and active otherwise `false`. */
+  is_profiling(name: string): boolean;
+  /** Returns `true` if the debugger is skipping breakpoints otherwise `false`. */
+  is_skipping_breakpoints(): boolean;
+  /**
+   * Forces a processing loop of debugger events. The purpose of this method is just processing events every now and then when the script might get too busy, so that bugs like infinite loops can be caught.
+   */
+  line_poll(): void;
+  /** Calls the `add` callable of the profiler with given `name` and `data`. */
+  profiler_add_frame_data(name: string, data: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  /**
+   * Calls the `toggle` callable of the profiler with given `name` and `arguments`. Enables/Disables the same profiler depending on `enable` argument.
+   */
+  profiler_enable(name: string, enable: boolean, arguments?: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  /**
+   * Registers a message capture with given `name`. If `name` is "my_message" then messages starting with "my_message:" will be called with the given callable.
+   * The callable must accept a message string and a data array as argument. The callable should return `true` if the message is recognized.
+   * **Note:** The callable will receive the message with the prefix stripped, unlike {@link EditorDebuggerPlugin._capture}. See the {@link EditorDebuggerPlugin} description for an example.
+   */
+  register_message_capture(name: string, callable: Callable): void;
+  /** Registers a profiler with the given `name`. See {@link EngineProfiler} for more information. */
+  register_profiler(name: string, profiler: EngineProfiler): void;
+  /** Removes a breakpoint with the given `source` and `line`. */
+  remove_breakpoint(line: int, source: string): void;
+  /**
+   * Starts a debug break in script execution, optionally specifying whether the program can continue based on `can_continue` and whether the break was due to a breakpoint.
+   */
+  script_debug(language: ScriptLanguage, can_continue?: boolean, is_error_breakpoint?: boolean): void;
+  /** Sends a message with given `message` and `data` array. */
+  send_message(message: string | NodePath, data: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  /** Sets the current debugging depth. */
+  set_depth(depth: int): void;
+  /** Sets the current debugging lines that remain. */
+  set_lines_left(lines: int): void;
+  /** Unregisters the message capture with given `name`. */
+  unregister_message_capture(name: string): void;
+  /** Unregisters a profiler with given `name`. */
+  unregister_profiler(name: string): void;
+}
+declare const EngineDebugger: EngineDebugger;
+

package/typings/classes/EngineProfiler.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for creating custom profilers. */
+declare class EngineProfiler extends RefCounted {
+  /** Called when data is added to profiler using {@link EngineDebugger.profiler_add_frame_data}. */
+  _add_frame(data: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  /**
+   * Called once every engine iteration when the profiler is active with information about the current frame. All time values are in seconds. Lower values represent faster processing times and are therefore considered better.
+   */
+  _tick(frame_time: float, process_time: float, physics_time: float, physics_frame_time: float): void;
+  /** Called when the profiler is enabled/disabled, along with a set of `options`. */
+  _toggle(enable: boolean, options: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+}