typescript-to-gdscript 0.1.0

package/typings/classes/SceneState.d.ts

@@ -0,0 +1,93 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides access to a scene file's information. */
+declare class SceneState extends RefCounted {
+  /**
+   * Returns the {@link SceneState} of the scene that this scene inherits from, or `null` if it doesn't inherit from any scene.
+   */
+  get_base_scene_state(): SceneState | null;
+  /** Returns the list of bound parameters for the signal at `idx`. */
+  get_connection_binds(idx: int): Array<unknown>;
+  /**
+   * Returns the number of signal connections in the scene.
+   * The `idx` argument used to query connection metadata in other `get_connection_*` methods in the interval `[0, get_connection_count() - 1]`.
+   */
+  get_connection_count(): int;
+  /** Returns the connection flags for the signal at `idx`. See {@link Object.ConnectFlags} constants. */
+  get_connection_flags(idx: int): int;
+  /** Returns the method connected to the signal at `idx`. */
+  get_connection_method(idx: int): string;
+  /** Returns the name of the signal at `idx`. */
+  get_connection_signal(idx: int): string;
+  /** Returns the path to the node that owns the signal at `idx`, relative to the root node. */
+  get_connection_source(idx: int): NodePath;
+  /**
+   * Returns the path to the node that owns the method connected to the signal at `idx`, relative to the root node.
+   */
+  get_connection_target(idx: int): NodePath;
+  /** Returns the number of unbound parameters for the signal at `idx`. */
+  get_connection_unbinds(idx: int): int;
+  /**
+   * Returns the number of nodes in the scene.
+   * The `idx` argument used to query node data in other `get_node_*` methods in the interval `[0, get_node_count() - 1]`.
+   */
+  get_node_count(): int;
+  /** Returns the list of group names associated with the node at `idx`. */
+  get_node_groups(idx: int): PackedStringArray;
+  /**
+   * Returns the node's index, which is its position relative to its siblings. This is only relevant and saved in scenes for cases where new nodes are added to an instantiated or inherited scene among siblings from the base scene. Despite the name, this index is not related to the `idx` argument used here and in other methods.
+   */
+  get_node_index(idx: int): int;
+  /**
+   * Returns a {@link PackedScene} for the node at `idx` (i.e. the whole branch starting at this node, with its child nodes and resources), or `null` if the node is not an instance.
+   */
+  get_node_instance(idx: int): PackedScene | null;
+  /**
+   * Returns the path to the represented scene file if the node at `idx` is an {@link InstancePlaceholder}.
+   */
+  get_node_instance_placeholder(idx: int): string;
+  /** Returns the name of the node at `idx`. */
+  get_node_name(idx: int): string;
+  /** Returns the path to the owner of the node at `idx`, relative to the root node. */
+  get_node_owner_path(idx: int): NodePath;
+  /**
+   * Returns the path to the node at `idx`.
+   * If `for_parent` is `true`, returns the path of the `idx` node's parent instead.
+   */
+  get_node_path(idx: int, for_parent?: boolean): NodePath;
+  /**
+   * Returns the number of exported or overridden properties for the node at `idx`.
+   * The `prop_idx` argument used to query node property data in other `get_node_property_*` methods in the interval `[0, get_node_property_count() - 1]`.
+   */
+  get_node_property_count(idx: int): int;
+  /** Returns the name of the property at `prop_idx` for the node at `idx`. */
+  get_node_property_name(idx: int, prop_idx: int): string;
+  /** Returns the value of the property at `prop_idx` for the node at `idx`. */
+  get_node_property_value(idx: int, prop_idx: int): unknown;
+  /** Returns the type of the node at `idx`. */
+  get_node_type(idx: int): string;
+  /** Returns the resource path to the represented {@link PackedScene}. */
+  get_path(): string;
+  /** Returns `true` if the node at `idx` is an {@link InstancePlaceholder}. */
+  is_node_instance_placeholder(idx: int): boolean;
+
+  // enum GenEditState
+  /** If passed to {@link PackedScene.instantiate}, blocks edits to the scene state. */
+  static readonly GEN_EDIT_STATE_DISABLED: int;
+  /**
+   * If passed to {@link PackedScene.instantiate}, provides inherited scene resources to the local scene.
+   * **Note:** Only available in editor builds.
+   */
+  static readonly GEN_EDIT_STATE_INSTANCE: int;
+  /**
+   * If passed to {@link PackedScene.instantiate}, provides local scene resources to the local scene. Only the main scene should receive the main edit state.
+   * **Note:** Only available in editor builds.
+   */
+  static readonly GEN_EDIT_STATE_MAIN: int;
+  /**
+   * If passed to {@link PackedScene.instantiate}, it's similar to {@link GEN_EDIT_STATE_MAIN}, but for the case where the scene is being instantiated to be the base of another one.
+   * **Note:** Only available in editor builds.
+   */
+  static readonly GEN_EDIT_STATE_MAIN_INHERITED: int;
+}

package/typings/classes/SceneTree.d.ts

@@ -0,0 +1,257 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Manages the game loop via a hierarchy of nodes. */
+declare class SceneTree extends MainLoop {
+  /**
+   * If `true`, the application automatically accepts quitting requests.
+   * For mobile platforms, see {@link quit_on_go_back}.
+   */
+  auto_accept_quit: boolean;
+  /**
+   * The root node of the currently loaded main scene, usually as a direct child of {@link root}. See also {@link change_scene_to_file}, {@link change_scene_to_packed}, and {@link reload_current_scene}.
+   * **Warning:** Setting this property directly may not work as expected, as it does *not* add or remove any nodes from this tree.
+   */
+  current_scene: Node | null;
+  /**
+   * If `true`, collision shapes will be visible when running the game from the editor for debugging purposes.
+   * **Note:** This property is not designed to be changed at run-time. Changing the value of {@link debug_collisions_hint} while the project is running will not have the desired effect.
+   */
+  debug_collisions_hint: boolean;
+  /**
+   * If `true`, navigation polygons will be visible when running the game from the editor for debugging purposes.
+   * **Note:** This property is not designed to be changed at run-time. Changing the value of {@link debug_navigation_hint} while the project is running will not have the desired effect.
+   */
+  debug_navigation_hint: boolean;
+  /**
+   * If `true`, curves from {@link Path2D} and {@link Path3D} nodes will be visible when running the game from the editor for debugging purposes.
+   * **Note:** This property is not designed to be changed at run-time. Changing the value of {@link debug_paths_hint} while the project is running will not have the desired effect.
+   */
+  debug_paths_hint: boolean;
+  /**
+   * The root of the scene currently being edited in the editor. This is usually a direct child of {@link root}.
+   * **Note:** This property does nothing in release builds.
+   */
+  edited_scene_root: Node | null;
+  /**
+   * If `true` (default value), enables automatic polling of the {@link MultiplayerAPI} for this SceneTree during {@link process_frame}.
+   * If `false`, you need to manually call {@link MultiplayerAPI.poll} to process network packets and deliver RPCs. This allows running RPCs in a different loop (e.g. physics, thread, specific time step) and for manual {@link Mutex} protection when accessing the {@link MultiplayerAPI} from threads.
+   */
+  multiplayer_poll: boolean;
+  /**
+   * If `true`, the scene tree is considered paused. This causes the following behavior:
+   * - 2D and 3D physics will be stopped, as well as collision detection and related signals.
+   * - Depending on each node's {@link Node.process_mode}, their {@link Node._process}, {@link Node._physics_process} and {@link Node._input} callback methods may not called anymore.
+   */
+  paused: boolean;
+  /**
+   * If `true`, the renderer will interpolate the transforms of objects (both physics and non-physics) between the last two transforms, so that smooth motion is seen even when physics ticks do not coincide with rendered frames.
+   * The default value of this property is controlled by {@link ProjectSettings.physics/common/physics_interpolation}.
+   * **Note:** Although this is a global setting, finer control of individual branches of the {@link SceneTree} is possible using {@link Node.physics_interpolation_mode}.
+   */
+  physics_interpolation: boolean;
+  /**
+   * If `true`, the application quits automatically when navigating back (e.g. using the system "Back" button on Android).
+   * To handle 'Go Back' button when this option is disabled, use {@link DisplayServer.WINDOW_EVENT_GO_BACK_REQUEST}.
+   */
+  quit_on_go_back: boolean;
+  /**
+   * The tree's root {@link Window}. This is top-most {@link Node} of the scene tree, and is always present. An absolute {@link NodePath} always starts from this node. Children of the root node may include the loaded {@link current_scene}, as well as any AutoLoad ($DOCS_URL/tutorials/scripting/singletons_autoload.html) configured in the Project Settings.
+   * **Warning:** Do not delete this node. This will result in unstable behavior, followed by a crash.
+   */
+  root: Window;
+  set_auto_accept_quit(value: boolean): void;
+  is_auto_accept_quit(): boolean;
+  set_current_scene(value: Node | null): void;
+  get_current_scene(): Node | null;
+  set_debug_collisions_hint(value: boolean): void;
+  is_debugging_collisions_hint(): boolean;
+  set_debug_navigation_hint(value: boolean): void;
+  is_debugging_navigation_hint(): boolean;
+  set_debug_paths_hint(value: boolean): void;
+  is_debugging_paths_hint(): boolean;
+  set_edited_scene_root(value: Node | null): void;
+  get_edited_scene_root(): Node | null;
+  set_multiplayer_poll_enabled(value: boolean): void;
+  is_multiplayer_poll_enabled(): boolean;
+  set_pause(value: boolean): void;
+  is_paused(): boolean;
+  set_physics_interpolation_enabled(value: boolean): void;
+  is_physics_interpolation_enabled(): boolean;
+  set_quit_on_go_back(value: boolean): void;
+  is_quit_on_go_back(): boolean;
+  get_root(): Window;
+
+  /**
+   * Calls `method` on each node inside this tree added to the given `group`. You can pass arguments to `method` by specifying them at the end of this method call. Nodes that cannot call `method` (either because the method doesn't exist or the arguments do not match) are ignored. See also {@link set_group} and {@link notify_group}.
+   * **Note:** This method acts immediately on all selected nodes at once, which may cause stuttering in some performance-intensive situations.
+   * **Note:** In C#, `method` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `MethodName` class to avoid allocating a new {@link StringName} on each call.
+   */
+  call_group(group: GodotGroupNames, method: string, ...args: any[]): void;
+  call_group(group: string, method: string, ...args: any[]): void;
+  /**
+   * Calls the given `method` on each node inside this tree added to the given `group`. Use `flags` to customize this method's behavior (see {@link GroupCallFlags}). Additional arguments for `method` can be passed at the end of this method. Nodes that cannot call `method` (either because the method doesn't exist or the arguments do not match) are ignored.
+   * **Note:** In C#, `method` must be in snake_case when referring to built-in Godot methods. Prefer using the names exposed in the `MethodName` class to avoid allocating a new {@link StringName} on each call.
+   */
+  call_group_flags(flags: int, group: GodotGroupNames, method: string, ...args: any[]): void;
+  call_group_flags(flags: int, group: string, method: string, ...args: any[]): void;
+  /**
+   * Changes the running scene to the one at the given `path`, after loading it into a {@link PackedScene} and creating a new instance.
+   * Returns {@link OK} on success, {@link ERR_CANT_OPEN} if the `path` cannot be loaded into a {@link PackedScene}, or {@link ERR_CANT_CREATE} if that scene cannot be instantiated.
+   * **Note:** See {@link change_scene_to_node} for details on the order of operations.
+   */
+  change_scene_to_file(path: GodotScenePaths): int;
+  change_scene_to_file(path: string): int;
+  /**
+   * Changes the running scene to the provided {@link Node}. Useful when you want to set up the new scene before changing.
+   * Returns {@link OK} on success, {@link ERR_INVALID_PARAMETER} if the `node` is `null`, or {@link ERR_UNCONFIGURED} if the `node` is already inside the scene tree.
+   * **Note:** Operations happen in the following order when {@link change_scene_to_node} is called:
+   * 1. The current scene node is immediately removed from the tree. From that point, {@link Node.get_tree} called on the current (outgoing) scene will return `null`. {@link current_scene} will be `null` too, because the new scene is not available yet.
+   * 2. At the end of the frame, the formerly current scene, already removed from the tree, will be deleted (freed from memory) and then the new scene node will be added to the tree. {@link Node.get_tree} and {@link current_scene} will be back to working as usual.
+   * This ensures that both scenes aren't running at the same time, while still freeing the previous scene in a safe way similar to {@link Node.queue_free}.
+   * If you want to reliably access the new scene, await the {@link scene_changed} signal.
+   * **Warning:** After using this method, the {@link SceneTree} will take ownership of the node and will free it automatically when changing scene again. Any references you had to that node will become invalid.
+   */
+  change_scene_to_node(node: Node): int;
+  /**
+   * Changes the running scene to a new instance of the given {@link PackedScene} (which must be valid).
+   * Returns {@link OK} on success, {@link ERR_CANT_CREATE} if the scene cannot be instantiated, or {@link ERR_INVALID_PARAMETER} if the scene is invalid.
+   * **Note:** See {@link change_scene_to_node} for details on the order of operations.
+   */
+  change_scene_to_packed(packed_scene: PackedScene): int;
+  /**
+   * Returns a new {@link SceneTreeTimer}. After `time_sec` in seconds have passed, the timer will emit {@link SceneTreeTimer.timeout} and will be automatically freed.
+   * If `process_always` is `false`, the timer will be paused when setting {@link SceneTree.paused} to `true`.
+   * If `process_in_physics` is `true`, the timer will update at the end of the physics frame, instead of the process frame.
+   * If `ignore_time_scale` is `true`, the timer will ignore {@link Engine.time_scale} and update with the real, elapsed time.
+   * This method is commonly used to create a one-shot delay timer, as in the following example:
+   * **Note:** The timer is always updated *after* all of the nodes in the tree. A node's {@link Node._process} method would be called before the timer updates (or {@link Node._physics_process} if `process_in_physics` is set to `true`).
+   */
+  create_timer(time_sec: float, process_always?: boolean, process_in_physics?: boolean, ignore_time_scale?: boolean): SceneTreeTimer;
+  /**
+   * Creates and returns a new {@link Tween} processed in this tree. The Tween will start automatically on the next process frame or physics frame (depending on its {@link Tween.TweenProcessMode}).
+   * **Note:** A {@link Tween} created using this method is not bound to any {@link Node}. It may keep working until there is nothing left to animate. If you want the {@link Tween} to be automatically killed when the {@link Node} is freed, use {@link Node.create_tween} or {@link Tween.bind_node}.
+   */
+  create_tween(): Tween;
+  /**
+   * Returns the first {@link Node} found inside the tree, that has been added to the given `group`, in scene hierarchy order. Returns `null` if no match is found. See also {@link get_nodes_in_group}.
+   */
+  get_first_node_in_group<G extends string>(group: G): GodotGroupNodes<G>;
+  /**
+   * Returns how many physics process steps have been processed, since the application started. This is *not* a measurement of elapsed time. See also {@link physics_frame}. For the number of frames rendered, see {@link Engine.get_process_frames}.
+   */
+  get_frame(): int;
+  /**
+   * Searches for the {@link MultiplayerAPI} configured for the given path, if one does not exist it searches the parent paths until one is found. If the path is empty, or none is found, the default one is returned. See {@link set_multiplayer}.
+   */
+  get_multiplayer(for_path?: NodePath | string): MultiplayerAPI;
+  /** Returns the number of nodes inside this tree. */
+  get_node_count(): int;
+  /** Returns the number of nodes assigned to the given group. */
+  get_node_count_in_group(group: GodotGroupNames): int;
+  get_node_count_in_group(group: string): int;
+  /**
+   * Returns an {@link Array} containing all nodes inside this tree, that have been added to the given `group`, in scene hierarchy order.
+   */
+  get_nodes_in_group<G extends string>(group: G): Array<GodotGroupNodes<G>>;
+  /** Returns an {@link Array} of currently existing {@link Tween}s in the tree, including paused tweens. */
+  get_processed_tweens(): Array<Tween>;
+  /** Returns `true` if a node added to the given group `name` exists in the tree. */
+  has_group(name: GodotGroupNames): boolean;
+  has_group(name: string): boolean;
+  /**
+   * Returns `true` if accessibility features are enabled, and accessibility information updates are actively processed.
+   */
+  is_accessibility_enabled(): boolean;
+  /** Returns `true` if accessibility features are supported by the OS and enabled in project settings. */
+  is_accessibility_supported(): boolean;
+  /**
+   * Calls {@link Object.notification} with the given `notification` to all nodes inside this tree added to the `group`. See also Godot notifications ($DOCS_URL/tutorials/best_practices/godot_notifications.html) and {@link call_group} and {@link set_group}.
+   * **Note:** This method acts immediately on all selected nodes at once, which may cause stuttering in some performance-intensive situations.
+   */
+  notify_group(group: GodotGroupNames, notification: int): void;
+  notify_group(group: string, notification: int): void;
+  /**
+   * Calls {@link Object.notification} with the given `notification` to all nodes inside this tree added to the `group`. Use `call_flags` to customize this method's behavior (see {@link GroupCallFlags}).
+   */
+  notify_group_flags(call_flags: int, group: GodotGroupNames, notification: int): void;
+  notify_group_flags(call_flags: int, group: string, notification: int): void;
+  /**
+   * Queues the given `obj` to be deleted, calling its {@link Object.free} at the end of the current frame. This method is similar to {@link Node.queue_free}.
+   */
+  queue_delete(obj: GodotObject): void;
+  /**
+   * Quits the application at the end of the current iteration, with the given `exit_code`.
+   * By convention, an exit code of `0` indicates success, whereas any other exit code indicates an error. For portability reasons, it should be between `0` and `125` (inclusive).
+   * **Note:** On iOS this method doesn't work. Instead, as recommended by the iOS Human Interface Guidelines (https://developer.apple.com/library/archive/qa/qa1561/_index.html), the user is expected to close apps via the Home button.
+   */
+  quit(exit_code?: int): void;
+  /**
+   * Reloads the currently active scene, replacing {@link current_scene} with a new instance of its original {@link PackedScene}.
+   * Returns {@link OK} on success, {@link ERR_UNCONFIGURED} if no {@link current_scene} is defined, {@link ERR_CANT_OPEN} if {@link current_scene} cannot be loaded into a {@link PackedScene}, or {@link ERR_CANT_CREATE} if the scene cannot be instantiated.
+   */
+  reload_current_scene(): int;
+  /**
+   * Sets the given `property` to `value` on all nodes inside this tree added to the given `group`. Nodes that do not have the `property` are ignored. See also {@link call_group} and {@link notify_group}.
+   * **Note:** This method acts immediately on all selected nodes at once, which may cause stuttering in some performance-intensive situations.
+   * **Note:** In C#, `property` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the `PropertyName` class to avoid allocating a new {@link StringName} on each call.
+   */
+  set_group(group: GodotGroupNames, property: string, value: unknown): void;
+  set_group(group: string, property: string, value: unknown): void;
+  /**
+   * Sets the given `property` to `value` on all nodes inside this tree added to the given `group`. Nodes that do not have the `property` are ignored. Use `call_flags` to customize this method's behavior (see {@link GroupCallFlags}).
+   * **Note:** In C#, `property` must be in snake_case when referring to built-in Godot properties. Prefer using the names exposed in the `PropertyName` class to avoid allocating a new {@link StringName} on each call.
+   */
+  set_group_flags(call_flags: int, group: GodotGroupNames, property: string, value: unknown): void;
+  set_group_flags(call_flags: int, group: string, property: string, value: unknown): void;
+  /**
+   * Sets a custom {@link MultiplayerAPI} with the given `root_path` (controlling also the relative subpaths), or override the default one if `root_path` is empty.
+   * **Note:** No {@link MultiplayerAPI} must be configured for the subpath containing `root_path`, nested custom multiplayers are not allowed. I.e. if one is configured for `"/root/Foo"` setting one for `"/root/Foo/Bar"` will cause an error.
+   * **Note:** {@link set_multiplayer} should be called *before* the child nodes are ready at the given `root_path`. If multiplayer nodes like {@link MultiplayerSpawner} or {@link MultiplayerSynchronizer} are added to the tree before the custom multiplayer API is set, they will not work.
+   */
+  set_multiplayer(multiplayer: MultiplayerAPI, root_path?: NodePath | string): void;
+  /** If a current scene is loaded, calling this method will unload it. */
+  unload_current_scene(): void;
+
+  /** Emitted when the `node` enters this tree. */
+  node_added: Signal<[Node]>;
+  /**
+   * Emitted when the `node`'s {@link Node.update_configuration_warnings} is called. Only emitted in the editor.
+   */
+  node_configuration_warning_changed: Signal<[Node]>;
+  /** Emitted when the `node` exits this tree. */
+  node_removed: Signal<[Node]>;
+  /** Emitted when the `node`'s {@link Node.name} is changed. */
+  node_renamed: Signal<[Node]>;
+  /** Emitted immediately before {@link Node._physics_process} is called on every node in this tree. */
+  physics_frame: Signal<[]>;
+  /** Emitted immediately before {@link Node._process} is called on every node in this tree. */
+  process_frame: Signal<[]>;
+  /**
+   * Emitted after the new scene is added to scene tree and initialized. Can be used to reliably access {@link current_scene} when changing scenes.
+   */
+  scene_changed: Signal<[]>;
+  /** Emitted any time the tree's hierarchy changes (nodes being moved, renamed, etc.). */
+  tree_changed: Signal<[]>;
+  /**
+   * Emitted when the {@link Node.process_mode} of any node inside the tree is changed. Only emitted in the editor, to update the visibility of disabled nodes.
+   */
+  tree_process_mode_changed: Signal<[]>;
+
+  // enum GroupCallFlags
+  /** Call nodes within a group with no special behavior (default). */
+  static readonly GROUP_CALL_DEFAULT: int;
+  /**
+   * Call nodes within a group in reverse tree hierarchy order (all nested children are called before their respective parent nodes).
+   */
+  static readonly GROUP_CALL_REVERSE: int;
+  /**
+   * Call nodes within a group at the end of the current frame (can be either process or physics frame), similar to {@link Object.call_deferred}.
+   */
+  static readonly GROUP_CALL_DEFERRED: int;
+  /**
+   * Call nodes within a group only once, even if the call is executed many times in the same frame. Must be combined with {@link GROUP_CALL_DEFERRED} to work.
+   * **Note:** Different arguments are not taken into account. Therefore, when the same call is executed with different arguments, only the first call will be performed.
+   */
+  static readonly GROUP_CALL_UNIQUE: int;
+}

package/typings/classes/SceneTreeTimer.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** One-shot timer. */
+declare class SceneTreeTimer extends RefCounted {
+  /** The time remaining (in seconds). */
+  time_left: float;
+  set_time_left(value: float): void;
+  get_time_left(): float;
+
+  /** Emitted when the timer reaches 0. */
+  timeout: Signal<[]>;
+}

package/typings/classes/Script.d.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A class stored as a resource. */
+declare class Script extends Resource {
+  /**
+   * The script source code or an empty string if source code is not available. When set, does not reload the class implementation automatically.
+   */
+  source_code: string;
+  set_source_code(value: string | NodePath): void;
+  get_source_code(): string;
+
+  /** Returns `true` if the script can be instantiated. */
+  can_instantiate(): boolean;
+  /** Returns the script directly inherited by this script. */
+  get_base_script(): Script | null;
+  /**
+   * Returns the class name associated with the script, if there is one. Returns an empty string otherwise.
+   * To give the script a global name, you can use the `class_name` keyword in GDScript and the `{@link GlobalClass}` attribute in C#.
+   */
+  get_global_name(): string;
+  /** Returns the script's base type. */
+  get_instance_base_type(): string;
+  /** Returns the default value of the specified property. */
+  get_property_default_value(property: string): unknown;
+  /**
+   * Returns a {@link Dictionary} mapping method names to their RPC configuration defined by this script.
+   */
+  get_rpc_config(): unknown;
+  /** Returns a dictionary containing constant names and their values. */
+  get_script_constant_map(): Dictionary;
+  /**
+   * Returns the list of methods in this {@link Script}.
+   * **Note:** The dictionaries returned by this method are formatted identically to those returned by {@link Object.get_method_list}.
+   */
+  get_script_method_list(): Array<Dictionary>;
+  /**
+   * Returns the list of properties in this {@link Script}.
+   * **Note:** The dictionaries returned by this method are formatted identically to those returned by {@link Object.get_property_list}.
+   */
+  get_script_property_list(): Array<Dictionary>;
+  /**
+   * Returns the list of signals defined in this {@link Script}.
+   * **Note:** The dictionaries returned by this method are formatted identically to those returned by {@link Object.get_signal_list}.
+   */
+  get_script_signal_list(): Array<Dictionary>;
+  /** Returns `true` if the script, or a base class, defines a signal with the given name. */
+  has_script_signal(signal_name: string): boolean;
+  /**
+   * Returns `true` if the script contains non-empty source code.
+   * **Note:** If a script does not have source code, this does not mean that it is invalid or unusable. For example, a {@link GDScript} that was exported with binary tokenization has no source code, but still behaves as expected and could be instantiated. This can be checked with {@link can_instantiate}.
+   */
+  has_source_code(): boolean;
+  /** Returns `true` if `base_object` is an instance of this script. */
+  instance_has(base_object: GodotObject): boolean;
+  /**
+   * Returns `true` if the script is an abstract script. An abstract script does not have a constructor and cannot be instantiated.
+   */
+  is_abstract(): boolean;
+  /** Returns `true` if the script is a tool script. A tool script can run in the editor. */
+  is_tool(): boolean;
+  /** Reloads the script's class implementation. Returns an error code. */
+  reload(keep_state?: boolean): int;
+}

package/typings/classes/ScriptBacktrace.d.ts

@@ -0,0 +1,63 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A captured backtrace of a specific script language. */
+declare class ScriptBacktrace extends RefCounted {
+  /**
+   * Converts the backtrace to a {@link String}, where the entire string will be indented by `indent_all` number of spaces, and the individual stack frames will be additionally indented by `indent_frames` number of spaces.
+   * **Note:** Calling {@link Object.to_string} on a {@link ScriptBacktrace} will produce the same output as calling {@link format} with all parameters left at their default values.
+   */
+  format(indent_all?: int, indent_frames?: int): string;
+  /** Returns the number of stack frames in the backtrace. */
+  get_frame_count(): int;
+  /** Returns the file name of the call site represented by the stack frame at the specified index. */
+  get_frame_file(index: int): string;
+  /** Returns the name of the function called at the stack frame at the specified index. */
+  get_frame_function(index: int): string;
+  /** Returns the line number of the call site represented by the stack frame at the specified index. */
+  get_frame_line(index: int): int;
+  /**
+   * Returns the number of global variables (e.g. autoload singletons) in the backtrace.
+   * **Note:** This will be non-zero only if the `include_variables` parameter was `true` when capturing the backtrace with {@link Engine.capture_script_backtraces}.
+   */
+  get_global_variable_count(): int;
+  /** Returns the name of the global variable at the specified index. */
+  get_global_variable_name(variable_index: int): string;
+  /**
+   * Returns the value of the global variable at the specified index.
+   * **Warning:** With GDScript backtraces, the returned {@link Variant} will be the variable's actual value, including any object references. This means that storing the returned {@link Variant} will prevent any such object from being deallocated, so it's generally recommended not to do so.
+   */
+  get_global_variable_value(variable_index: int): unknown;
+  /** Returns the name of the script language that this backtrace was captured from. */
+  get_language_name(): string;
+  /**
+   * Returns the number of local variables in the stack frame at the specified index.
+   * **Note:** This will be non-zero only if the `include_variables` parameter was `true` when capturing the backtrace with {@link Engine.capture_script_backtraces}.
+   */
+  get_local_variable_count(frame_index: int): int;
+  /**
+   * Returns the name of the local variable at the specified `variable_index` in the stack frame at the specified `frame_index`.
+   */
+  get_local_variable_name(frame_index: int, variable_index: int): string;
+  /**
+   * Returns the value of the local variable at the specified `variable_index` in the stack frame at the specified `frame_index`.
+   * **Warning:** With GDScript backtraces, the returned {@link Variant} will be the variable's actual value, including any object references. This means that storing the returned {@link Variant} will prevent any such object from being deallocated, so it's generally recommended not to do so.
+   */
+  get_local_variable_value(frame_index: int, variable_index: int): unknown;
+  /**
+   * Returns the number of member variables in the stack frame at the specified index.
+   * **Note:** This will be non-zero only if the `include_variables` parameter was `true` when capturing the backtrace with {@link Engine.capture_script_backtraces}.
+   */
+  get_member_variable_count(frame_index: int): int;
+  /**
+   * Returns the name of the member variable at the specified `variable_index` in the stack frame at the specified `frame_index`.
+   */
+  get_member_variable_name(frame_index: int, variable_index: int): string;
+  /**
+   * Returns the value of the member variable at the specified `variable_index` in the stack frame at the specified `frame_index`.
+   * **Warning:** With GDScript backtraces, the returned {@link Variant} will be the variable's actual value, including any object references. This means that storing the returned {@link Variant} will prevent any such object from being deallocated, so it's generally recommended not to do so.
+   */
+  get_member_variable_value(frame_index: int, variable_index: int): unknown;
+  /** Returns `true` if the backtrace has no stack frames. */
+  is_empty(): boolean;
+}

package/typings/classes/ScriptCreateDialog.d.ts

@@ -0,0 +1,17 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Godot editor's popup dialog for creating new {@link Script} files. */
+declare class ScriptCreateDialog extends ConfirmationDialog {
+  dialog_hide_on_ok: boolean;
+  ok_button_text: string;
+  title: string;
+  set_ok_button_text(value: string | NodePath): void;
+  get_ok_button_text(): string;
+
+  /** Prefills required fields to configure the ScriptCreateDialog for use. */
+  config(inherits: string | NodePath, path: string | NodePath, built_in_enabled?: boolean, load_enabled?: boolean): void;
+
+  /** Emitted when the user clicks the OK button. */
+  script_created: Signal<[Script]>;
+}

package/typings/classes/ScriptEditor.d.ts

@@ -0,0 +1,60 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Godot editor's script editor. */
+declare class ScriptEditor extends PanelContainer {
+  /**
+   * Removes the documentation for the given `script`.
+   * **Note:** This should be called whenever the script is changed to keep the open documentation state up to date.
+   */
+  clear_docs_from_script(script: Script): void;
+  /** Returns array of breakpoints. */
+  get_breakpoints(): PackedStringArray;
+  /** Returns the {@link ScriptEditorBase} object that the user is currently editing. */
+  get_current_editor(): ScriptEditorBase | null;
+  /** Returns a {@link Script} that is currently active in editor. */
+  get_current_script(): Script | null;
+  /** Returns an array with all {@link ScriptEditorBase} objects which are currently open in editor. */
+  get_open_script_editors(): Array<ScriptEditorBase>;
+  /** Returns an array with all {@link Script} objects which are currently open in editor. */
+  get_open_scripts(): Array<Script>;
+  /**
+   * Opens help for the given topic. The `topic` is an encoded string that controls which class, method, constant, signal, annotation, property, or theme item should be focused.
+   * The supported `topic` formats include `class_name:class`, `class_method:class:method`, `class_constant:class:constant`, `class_signal:class:signal`, `class_annotation:class:@annotation`, `class_property:class:property`, and `class_theme_item:class:item`, where `class` is the class name, `method` is the method name, `constant` is the constant name, `signal` is the signal name, `annotation` is the annotation name, `property` is the property name, and `item` is the theme item.
+   */
+  goto_help(topic: string | NodePath): void;
+  /** Goes to the specified line in the current script. */
+  goto_line(line_number: int): void;
+  /**
+   * Opens the script create dialog. The script will extend `base_name`. The file extension can be omitted from `base_path`. It will be added based on the selected scripting language.
+   */
+  open_script_create_dialog(base_name: string | NodePath, base_path: string | NodePath): void;
+  /**
+   * Registers the {@link EditorSyntaxHighlighter} to the editor, the {@link EditorSyntaxHighlighter} will be available on all open scripts.
+   * **Note:** Does not apply to scripts that are already opened.
+   */
+  register_syntax_highlighter(syntax_highlighter: EditorSyntaxHighlighter): void;
+  /**
+   * Reloads all currently opened files. This should be used when opened files are changed outside of the script editor. The user may be prompted to resolve file conflicts, see {@link EditorSettings.text_editor/behavior/files/auto_reload_scripts_on_external_change}.
+   */
+  reload_open_files(): void;
+  /** Saves all open scripts. */
+  save_all_scripts(): void;
+  /**
+   * Unregisters the {@link EditorSyntaxHighlighter} from the editor.
+   * **Note:** The {@link EditorSyntaxHighlighter} will still be applied to scripts that are already opened.
+   */
+  unregister_syntax_highlighter(syntax_highlighter: EditorSyntaxHighlighter): void;
+  /**
+   * Updates the documentation for the given `script`.
+   * **Note:** This should be called whenever the script is changed to keep the open documentation state up to date.
+   */
+  update_docs_from_script(script: Script): void;
+
+  /** Emitted when user changed active script. Argument is a freshly activated {@link Script}. */
+  editor_script_changed: Signal<[Script]>;
+  /**
+   * Emitted when editor is about to close the active script. Argument is a {@link Script} that is going to be closed.
+   */
+  script_close: Signal<[Script]>;
+}

package/typings/classes/ScriptEditorBase.d.ts

@@ -0,0 +1,39 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base editor for editing scripts in the {@link ScriptEditor}. */
+declare class ScriptEditorBase extends VBoxContainer {
+  /** Adds an {@link EditorSyntaxHighlighter} to the open script. */
+  add_syntax_highlighter(highlighter: EditorSyntaxHighlighter): void;
+  /**
+   * Returns the underlying {@link Control} used for editing scripts. For text scripts, this is a {@link CodeEdit}.
+   */
+  get_base_editor(): Control;
+
+  /** Emitted after script validation. */
+  edited_script_changed: Signal<[]>;
+  /** Emitted when the user requests a specific documentation page. */
+  go_to_help: Signal<[string]>;
+  /**
+   * Emitted when the user requests to view a specific method of a script, similar to {@link request_open_script_at_line}.
+   */
+  go_to_method: Signal<[GodotObject, string]>;
+  /** Emitted after script validation or when the edited resource has changed. */
+  name_changed: Signal<[]>;
+  /** Emitted when the user request to find and replace text in the file system. */
+  replace_in_files_requested: Signal<[string]>;
+  /** Emitted when the user requests contextual help. */
+  request_help: Signal<[string]>;
+  /**
+   * Emitted when the user requests to view a specific line of a script, similar to {@link go_to_method}.
+   */
+  request_open_script_at_line: Signal<[GodotObject, int]>;
+  /** Emitted when the user contextual goto and the item is in the same script. */
+  request_save_history: Signal<[]>;
+  /**
+   * Emitted when the user changes current script or moves caret by 10 or more columns within the same script.
+   */
+  request_save_previous_state: Signal<[Dictionary]>;
+  /** Emitted when the user request to search text in the file system. */
+  search_in_files_requested: Signal<[string]>;
+}