typescript-to-gdscript 0.1.0

package/typings/classes/EditorInspectorPlugin.d.ts

@@ -0,0 +1,34 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Plugin for adding custom property editors on the inspector. */
+declare class EditorInspectorPlugin extends RefCounted {
+  /** Returns `true` if this object can be handled by this plugin. */
+  _can_handle(object: GodotObject): boolean;
+  /** Called to allow adding controls at the beginning of the property list for `object`. */
+  _parse_begin(object: GodotObject): void;
+  /** Called to allow adding controls at the beginning of a category in the property list for `object`. */
+  _parse_category(object: GodotObject, category: string | NodePath): void;
+  /** Called to allow adding controls at the end of the property list for `object`. */
+  _parse_end(object: GodotObject): void;
+  /**
+   * Called to allow adding controls at the beginning of a group or a sub-group in the property list for `object`.
+   */
+  _parse_group(object: GodotObject, group: string | NodePath): void;
+  /**
+   * Called to allow adding property-specific editors to the property list for `object`. The added editor control must extend {@link EditorProperty}. Returning `true` removes the built-in editor for this property, otherwise allows to insert a custom editor before the built-in one.
+   */
+  _parse_property(object: GodotObject, type_: int, name: string | NodePath, hint_type: int, hint_string: string | NodePath, usage_flags: int, wide: boolean): boolean;
+  /** Adds a custom control, which is not necessarily a property editor. */
+  add_custom_control(control: Control): void;
+  /**
+   * Adds a property editor for an individual property. The `editor` control must extend {@link EditorProperty}.
+   * There can be multiple property editors for a property. If `add_to_end` is `true`, this newly added editor will be displayed after all the other editors of the property whose `add_to_end` is `false`. For example, the editor uses this parameter to add an "Edit Region" button for {@link Sprite2D.region_rect} below the regular {@link Rect2} editor.
+   * `label` can be used to choose a custom label for the property editor in the inspector. If left empty, the label is computed from the name of the property instead.
+   */
+  add_property_editor(property: string | NodePath, editor: Control, add_to_end?: boolean, label?: string | NodePath): void;
+  /**
+   * Adds an editor that allows modifying multiple properties. The `editor` control must extend {@link EditorProperty}.
+   */
+  add_property_editor_for_multiple_properties(label: string | NodePath, properties: PackedStringArray | Array<unknown>, editor: Control): void;
+}

package/typings/classes/EditorInterface.d.ts

@@ -0,0 +1,254 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Godot editor's interface. */
+declare interface EditorInterface extends GodotObject {
+  /**
+   * If `true`, enables distraction-free mode which hides side docks to increase the space available for the main view.
+   */
+  distraction_free_mode: boolean;
+  /**
+   * If `true`, the Movie Maker mode is enabled in the editor. See {@link MovieWriter} for more information.
+   */
+  movie_maker_enabled: boolean;
+  set_distraction_free_mode(value: boolean): void;
+  is_distraction_free_mode_enabled(): boolean;
+  set_movie_maker_enabled(value: boolean): void;
+  is_movie_maker_enabled(): boolean;
+
+  /**
+   * Makes `node` root of the currently opened scene. Only works if the scene is empty. If the `node` is a scene instance, an inheriting scene will be created.
+   */
+  add_root_node(node: Node): void;
+  /**
+   * Closes the currently active scene, discarding any pending changes in the process. Returns {@link OK} on success or {@link ERR_DOES_NOT_EXIST} if there is no scene to close.
+   */
+  close_scene(): int;
+  /** Edits the given {@link Node}. The node will be also selected if it's inside the scene tree. */
+  edit_node(node: Node): void;
+  /**
+   * Edits the given {@link Resource}. If the resource is a {@link Script} you can also edit it with {@link edit_script} to specify the line and column position.
+   */
+  edit_resource(resource: Resource): void;
+  /**
+   * Edits the given {@link Script}. The line and column on which to open the script can also be specified. The script will be open with the user-configured editor for the script's language which may be an external editor.
+   */
+  edit_script(script: Script, line?: int, column?: int, grab_focus?: boolean): void;
+  /**
+   * Returns the main container of Godot editor's window. For example, you can use it to retrieve the size of the container and place your controls accordingly.
+   * **Warning:** Removing and freeing this node will render the editor useless and may cause a crash.
+   */
+  get_base_control(): Control;
+  /**
+   * Returns the editor's {@link EditorCommandPalette} instance.
+   * **Warning:** Removing and freeing this node will render a part of the editor useless and may cause a crash.
+   */
+  get_command_palette(): EditorCommandPalette;
+  /**
+   * Returns the current directory being viewed in the {@link FileSystemDock}. If a file is selected, its base directory will be returned using {@link String.get_base_dir} instead.
+   */
+  get_current_directory(): string;
+  /**
+   * Returns the name of the currently activated feature profile. If the default profile is currently active, an empty string is returned instead.
+   * In order to get a reference to the {@link EditorFeatureProfile}, you must load the feature profile using {@link EditorFeatureProfile.load_from_file}.
+   * **Note:** Feature profiles created via the user interface are loaded from the `feature_profiles` directory, as a file with the `.profile` extension. The editor configuration folder can be found by using {@link EditorPaths.get_config_dir}.
+   */
+  get_current_feature_profile(): string;
+  /** Returns the current path being viewed in the {@link FileSystemDock}. */
+  get_current_path(): string;
+  /** Returns the edited (current) scene's root {@link Node}. */
+  get_edited_scene_root(): Node | null;
+  /** Returns the language currently used for the editor interface. */
+  get_editor_language(): string;
+  /**
+   * Returns the editor control responsible for main screen plugins and tools. Use it with plugins that implement {@link EditorPlugin._has_main_screen}.
+   * **Note:** This node is a {@link VBoxContainer}, which means that if you add a {@link Control} child to it, you need to set the child's {@link Control.size_flags_vertical} to {@link Control.SIZE_EXPAND_FILL} to make it use the full available space.
+   * **Warning:** Removing and freeing this node will render a part of the editor useless and may cause a crash.
+   */
+  get_editor_main_screen(): VBoxContainer;
+  /** Returns the {@link EditorPaths} singleton. */
+  get_editor_paths(): EditorPaths;
+  /**
+   * Returns the actual scale of the editor UI (`1.0` being 100% scale). This can be used to adjust position and dimensions of the UI added by plugins.
+   * **Note:** This value is set via the {@link EditorSettings.interface/editor/appearance/display_scale} and {@link EditorSettings.interface/editor/appearance/custom_display_scale} settings. The editor must be restarted for changes to be properly applied.
+   */
+  get_editor_scale(): float;
+  /** Returns the editor's {@link EditorSettings} instance. */
+  get_editor_settings(): EditorSettings;
+  /**
+   * Returns the editor's {@link Theme}.
+   * **Note:** When creating custom editor UI, prefer accessing theme items directly from your GUI nodes using the `get_theme_*` methods.
+   */
+  get_editor_theme(): Theme;
+  /** Returns the editor's {@link EditorToaster}. */
+  get_editor_toaster(): EditorToaster;
+  /** Returns the editor's {@link EditorUndoRedoManager}. */
+  get_editor_undo_redo(): EditorUndoRedoManager;
+  /**
+   * Returns the 2D editor {@link SubViewport}. It does not have a camera. Instead, the view transforms are done directly and can be accessed with {@link Viewport.global_canvas_transform}.
+   */
+  get_editor_viewport_2d(): SubViewport;
+  /**
+   * Returns the specified 3D editor {@link SubViewport}, from `0` to `3`. The viewport can be used to access the active editor cameras with {@link Viewport.get_camera_3d}.
+   */
+  get_editor_viewport_3d(idx?: int): SubViewport;
+  /**
+   * Returns the editor's {@link FileSystemDock} instance.
+   * **Warning:** Removing and freeing this node will render a part of the editor useless and may cause a crash.
+   */
+  get_file_system_dock(): FileSystemDock;
+  /**
+   * Returns the editor's {@link EditorInspector} instance.
+   * **Warning:** Removing and freeing this node will render a part of the editor useless and may cause a crash.
+   */
+  get_inspector(): EditorInspector;
+  /** Returns the amount of degrees the 3D editor's rotational snapping is set to. */
+  get_node_3d_rotate_snap(): float;
+  /** Returns the amount of units the 3D editor's scale snapping is set to. */
+  get_node_3d_scale_snap(): float;
+  /** Returns the amount of units the 3D editor's translation snapping is set to. */
+  get_node_3d_translate_snap(): float;
+  /** Returns an array with references to the root nodes of the currently opened scenes. */
+  get_open_scene_roots(): Array<Node>;
+  /** Returns an array with the file paths of the currently opened scenes. */
+  get_open_scenes(): PackedStringArray;
+  /**
+   * Returns the name of the scene that is being played. If no scene is currently being played, returns an empty string.
+   */
+  get_playing_scene(): string;
+  /** Returns the editor's {@link EditorFileSystem} instance. */
+  get_resource_filesystem(): EditorFileSystem;
+  /** Returns the editor's {@link EditorResourcePreview} instance. */
+  get_resource_previewer(): EditorResourcePreview;
+  /**
+   * Returns the editor's {@link ScriptEditor} instance.
+   * **Warning:** Removing and freeing this node will render a part of the editor useless and may cause a crash.
+   */
+  get_script_editor(): ScriptEditor;
+  /**
+   * Returns an array containing the paths of the currently selected files (and directories) in the {@link FileSystemDock}.
+   */
+  get_selected_paths(): PackedStringArray;
+  /** Returns the editor's {@link EditorSelection} instance. */
+  get_selection(): EditorSelection;
+  /** Returns an array of file paths of currently unsaved scenes. */
+  get_unsaved_scenes(): PackedStringArray;
+  /**
+   * Shows the given property on the given `object` in the editor's Inspector dock. If `inspector_only` is `true`, plugins will not attempt to edit `object`.
+   */
+  inspect_object(object: GodotObject, for_property?: string | NodePath, inspector_only?: boolean): void;
+  /**
+   * Returns `true` if multiple window support is enabled in the editor. Multiple window support is enabled if *all* of these statements are true:
+   * - {@link EditorSettings.interface/multi_window/enable} is `true`.
+   * - {@link EditorSettings.interface/editor/display/single_window_mode} is `false`.
+   * - {@link Viewport.gui_embed_subwindows} is `false`. This is forced to `true` on platforms that don't support multiple windows such as Web, or when the `--single-window` command line argument ($DOCS_URL/tutorials/editor/command_line_tutorial.html) is used.
+   */
+  is_multi_window_enabled(): boolean;
+  /** Returns `true` if the 3D editor currently has snapping mode enabled, and `false` otherwise. */
+  is_node_3d_snap_enabled(): boolean;
+  /** Returns `true` if the object has been marked as edited through {@link set_object_edited}. */
+  is_object_edited(object: GodotObject): boolean;
+  /**
+   * Returns `true` if a scene is currently being played, `false` otherwise. Paused scenes are considered as being played.
+   */
+  is_playing_scene(): boolean;
+  /**
+   * Returns `true` if the specified `plugin` is enabled. The plugin name is the same as its directory name.
+   */
+  is_plugin_enabled(plugin: string | NodePath): boolean;
+  /** Returns mesh previews rendered at the given size as an {@link Array} of {@link Texture2D}s. */
+  make_mesh_previews(meshes: Array<Mesh>, preview_size: int): Array<Texture2D>;
+  /** Marks the current scene tab as unsaved. */
+  mark_scene_as_unsaved(): void;
+  /** Opens the scene at the given path. If `set_inherited` is `true`, creates a new inherited scene. */
+  open_scene_from_path(scene_filepath: string | NodePath, set_inherited?: boolean): void;
+  /** Plays the currently active scene. */
+  play_current_scene(): void;
+  /** Plays the scene specified by its filepath. */
+  play_custom_scene(scene_filepath: string | NodePath): void;
+  /** Plays the main scene. */
+  play_main_scene(): void;
+  /**
+   * Pops up an editor dialog for creating an object.
+   * The `callback` must take a single argument of type {@link String}, which will contain the type name of the selected object (or the script path of the type, if the type is created from a script), or be an empty string if no item is selected.
+   * The `base_type` specifies the base type of objects to display. For example, if you set this to "Resource", all types derived from {@link Resource} will display in the create dialog.
+   * The `current_type` will be passed in the search box of the create dialog, and the specified type can be immediately selected when the dialog pops up. If the `current_type` is not derived from `base_type`, there will be no result of the type in the dialog.
+   * The `dialog_title` allows you to define a custom title for the dialog. This is useful if you want to accurately hint the usage of the dialog. If the `dialog_title` is an empty string, the dialog will use "Create New 'Base Type'" as the default title.
+   * The `type_blocklist` contains a list of type names, and the types in the blocklist will be hidden from the create dialog.
+   * **Note:** Trying to list the base type in the `type_blocklist` will hide all types derived from the base type from the create dialog.
+   */
+  popup_create_dialog(callback: Callable, base_type?: string, current_type?: string | NodePath, dialog_title?: string | NodePath, type_blocklist?: Array<string>): void;
+  /**
+   * Pops up the `dialog` in the editor UI with {@link Window.popup_exclusive}. The dialog must have no current parent, otherwise the method fails.
+   * See also {@link Window.set_unparent_when_invisible}.
+   */
+  popup_dialog(dialog: Window, rect?: Rect2i | Rect2): void;
+  /**
+   * Pops up the `dialog` in the editor UI with {@link Window.popup_exclusive_centered}. The dialog must have no current parent, otherwise the method fails.
+   * See also {@link Window.set_unparent_when_invisible}.
+   */
+  popup_dialog_centered(dialog: Window, minsize?: Vector2i | Vector2): void;
+  /**
+   * Pops up the `dialog` in the editor UI with {@link Window.popup_exclusive_centered_clamped}. The dialog must have no current parent, otherwise the method fails.
+   * See also {@link Window.set_unparent_when_invisible}.
+   */
+  popup_dialog_centered_clamped(dialog: Window, minsize?: Vector2i | Vector2, fallback_ratio?: float): void;
+  /**
+   * Pops up the `dialog` in the editor UI with {@link Window.popup_exclusive_centered_ratio}. The dialog must have no current parent, otherwise the method fails.
+   * See also {@link Window.set_unparent_when_invisible}.
+   */
+  popup_dialog_centered_ratio(dialog: Window, ratio?: float): void;
+  /**
+   * Pops up an editor dialog for selecting a method from `object`. The `callback` must take a single argument of type {@link String} which will contain the name of the selected method or be empty if the dialog is canceled. If `current_value` is provided, the method will be selected automatically in the method list, if it exists.
+   */
+  popup_method_selector(object: GodotObject, callback: Callable, current_value?: string | NodePath): void;
+  /**
+   * Pops up an editor dialog for selecting a {@link Node} from the edited scene. The `callback` must take a single argument of type {@link NodePath}. It is called on the selected {@link NodePath} or the empty path `^""` if the dialog is canceled. If `valid_types` is provided, the dialog will only show Nodes that match one of the listed Node types. If `current_value` is provided, the Node will be automatically selected in the tree, if it exists.
+   * **Example:** Display the node selection dialog as soon as this node is added to the tree for the first time:
+   */
+  popup_node_selector(callback: Callable, valid_types?: Array<string>, current_value?: Node): void;
+  /**
+   * Pops up an editor dialog for selecting properties from `object`. The `callback` must take a single argument of type {@link NodePath}. It is called on the selected property path (see {@link NodePath.get_as_property_path}) or the empty path `^""` if the dialog is canceled. If `type_filter` is provided, the dialog will only show properties that match one of the listed {@link Variant.Type} values. If `current_value` is provided, the property will be selected automatically in the property list, if it exists.
+   */
+  popup_property_selector(object: GodotObject, callback: Callable, type_filter?: PackedInt32Array | Array<unknown>, current_value?: string | NodePath): void;
+  /**
+   * Pops up an editor dialog for quick selecting a resource file. The `callback` must take a single argument of type {@link String} which will contain the path of the selected resource or be empty if the dialog is canceled. If `base_types` is provided, the dialog will only show resources that match these types. Only types deriving from {@link Resource} are supported.
+   */
+  popup_quick_open(callback: Callable, base_types?: Array<string>): void;
+  /** Reloads the scene at the given path. */
+  reload_scene_from_path(scene_filepath: string | NodePath): void;
+  /**
+   * Restarts the editor. This closes the editor and then opens the same project. If `save` is `true`, the project will be saved before restarting.
+   */
+  restart_editor(save?: boolean): void;
+  /** Saves all opened scenes in the editor. */
+  save_all_scenes(): void;
+  /** Saves the currently active scene. Returns either {@link OK} or {@link ERR_CANT_CREATE}. */
+  save_scene(): int;
+  /** Saves the currently active scene as a file at `path`. */
+  save_scene_as(path: string | NodePath, with_preview?: boolean): void;
+  /** Selects the file, with the path provided by `file`, in the FileSystem dock. */
+  select_file(file: string | NodePath): void;
+  /**
+   * Selects and activates the specified feature profile with the given `profile_name`. Set `profile_name` to an empty string to reset to the default feature profile.
+   * A feature profile can be created programmatically using the {@link EditorFeatureProfile} class.
+   * **Note:** The feature profile that gets activated must be located in the `feature_profiles` directory, as a file with the `.profile` extension. If a profile could not be found, an error occurs. The editor configuration folder can be found by using {@link EditorPaths.get_config_dir}.
+   */
+  set_current_feature_profile(profile_name: string | NodePath): void;
+  /**
+   * Sets the editor's current main screen to the one specified in `name`. `name` must match the title of the tab in question exactly (e.g. `2D`, `3D`, [code skip-lint]Script[/code], `Game`, or `AssetLib` for default tabs).
+   */
+  set_main_screen_editor(name: string | NodePath): void;
+  /**
+   * If `edited` is `true`, the object is marked as edited.
+   * **Note:** This is primarily used by the editor for {@link Resource} based objects to track their modified state. For example, any changes to an open scene, a resource in the inspector, or an edited script will cause this method to be called with `true`. Saving the scene, script, or resource resets the edited state by calling this method with `false`.
+   * **Note:** Each call to this method increments the object's edited version. This is used to track changes in the editor and to trigger when thumbnails should be regenerated for resources.
+   */
+  set_object_edited(object: GodotObject, edited: boolean): void;
+  /** Sets the enabled status of a plugin. The plugin name is the same as its directory name. */
+  set_plugin_enabled(plugin: string | NodePath, enabled: boolean): void;
+  /** Stops the scene that is currently playing. */
+  stop_playing_scene(): void;
+}
+declare const EditorInterface: EditorInterface;
+

package/typings/classes/EditorNode3DGizmo.d.ts

@@ -0,0 +1,104 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Gizmo for editing {@link Node3D} objects. */
+declare class EditorNode3DGizmo extends Node3DGizmo {
+  _begin_handle_action(id: int, secondary: boolean): void;
+  /**
+   * Override this method to commit a handle being edited (handles must have been previously added by {@link add_handles}). This usually means creating an {@link UndoRedo} action for the change, using the current handle value as "do" and the `restore` argument as "undo".
+   * If the `cancel` argument is `true`, the `restore` value should be directly set, without any {@link UndoRedo} action.
+   * The `secondary` argument is `true` when the committed handle is secondary (see {@link add_handles} for more information).
+   */
+  _commit_handle(id: int, secondary: boolean, restore: unknown, cancel: boolean): void;
+  /**
+   * Override this method to commit a group of subgizmos being edited (see {@link _subgizmos_intersect_ray} and {@link _subgizmos_intersect_frustum}). This usually means creating an {@link UndoRedo} action for the change, using the current transforms as "do" and the `restores` transforms as "undo".
+   * If the `cancel` argument is `true`, the `restores` transforms should be directly set, without any {@link UndoRedo} action.
+   */
+  _commit_subgizmos(ids: PackedInt32Array | Array<unknown>, restores: Array<Transform3D>, cancel: boolean): void;
+  /**
+   * Override this method to return the name of an edited handle (handles must have been previously added by {@link add_handles}). Handles can be named for reference to the user when editing.
+   * The `secondary` argument is `true` when the requested handle is secondary (see {@link add_handles} for more information).
+   */
+  _get_handle_name(id: int, secondary: boolean): string;
+  /**
+   * Override this method to return the current value of a handle. This value will be requested at the start of an edit and used as the `restore` argument in {@link _commit_handle}.
+   * The `secondary` argument is `true` when the requested handle is secondary (see {@link add_handles} for more information).
+   */
+  _get_handle_value(id: int, secondary: boolean): unknown;
+  /**
+   * Override this method to return the current transform of a subgizmo. This transform will be requested at the start of an edit and used as the `restore` argument in {@link _commit_subgizmos}.
+   */
+  _get_subgizmo_transform(id: int): Transform3D;
+  /**
+   * Override this method to return `true` whenever the given handle should be highlighted in the editor.
+   * The `secondary` argument is `true` when the requested handle is secondary (see {@link add_handles} for more information).
+   */
+  _is_handle_highlighted(id: int, secondary: boolean): boolean;
+  /**
+   * Override this method to add all the gizmo elements whenever a gizmo update is requested. It's common to call {@link clear} at the beginning of this method and then add visual elements depending on the node's properties.
+   */
+  _redraw(): void;
+  /**
+   * Override this method to update the node properties when the user drags a gizmo handle (previously added with {@link add_handles}). The provided `point` is the mouse position in screen coordinates and the `camera` can be used to convert it to raycasts.
+   * The `secondary` argument is `true` when the edited handle is secondary (see {@link add_handles} for more information).
+   */
+  _set_handle(id: int, secondary: boolean, camera: Camera3D, point: Vector2 | Vector2i): void;
+  /**
+   * Override this method to update the node properties during subgizmo editing (see {@link _subgizmos_intersect_ray} and {@link _subgizmos_intersect_frustum}). The `transform` is given in the {@link Node3D}'s local coordinate system.
+   */
+  _set_subgizmo_transform(id: int, transform: Transform3D | Projection): void;
+  /**
+   * Override this method to allow selecting subgizmos using mouse drag box selection. Given a `camera` and a `frustum`, this method should return which subgizmos are contained within the frustum. The `frustum` argument consists of an array with all the {@link Plane}s that make up the selection frustum. The returned value should contain a list of unique subgizmo identifiers, which can have any non-negative value and will be used in other virtual methods like {@link _get_subgizmo_transform} or {@link _commit_subgizmos}.
+   */
+  _subgizmos_intersect_frustum(camera: Camera3D, frustum: Array<Plane>): PackedInt32Array;
+  /**
+   * Override this method to allow selecting subgizmos using mouse clicks. Given a `camera` and a `point` in screen coordinates, this method should return which subgizmo should be selected. The returned value should be a unique subgizmo identifier, which can have any non-negative value and will be used in other virtual methods like {@link _get_subgizmo_transform} or {@link _commit_subgizmos}.
+   */
+  _subgizmos_intersect_ray(camera: Camera3D, point: Vector2 | Vector2i): int;
+  /**
+   * Adds the specified `segments` to the gizmo's collision shape for picking. Call this method during {@link _redraw}.
+   */
+  add_collision_segments(segments: PackedVector3Array | Array<unknown>): void;
+  /**
+   * Adds collision triangles to the gizmo for picking. A {@link TriangleMesh} can be generated from a regular {@link Mesh} too. Call this method during {@link _redraw}.
+   */
+  add_collision_triangles(triangles: TriangleMesh): void;
+  /**
+   * Adds a list of handles (points) which can be used to edit the properties of the gizmo's {@link Node3D}. The `ids` argument can be used to specify a custom identifier for each handle, if an empty array is passed, the ids will be assigned automatically from the `handles` argument order.
+   * The `secondary` argument marks the added handles as secondary, meaning they will normally have lower selection priority than regular handles. When the user is holding the shift key secondary handles will switch to have higher priority than regular handles. This change in priority can be used to place multiple handles at the same point while still giving the user control on their selection.
+   * There are virtual methods which will be called upon editing of these handles. Call this method during {@link _redraw}.
+   */
+  add_handles(handles: PackedVector3Array | Array<unknown>, material: Material, ids: PackedInt32Array | Array<unknown>, billboard?: boolean, secondary?: boolean): void;
+  /**
+   * Adds lines to the gizmo (as sets of 2 points), with a given material. The lines are used for visualizing the gizmo. Call this method during {@link _redraw}.
+   */
+  add_lines(lines: PackedVector3Array | Array<unknown>, material: Material, billboard?: boolean, modulate?: Color): void;
+  /**
+   * Adds a mesh to the gizmo with the specified `material`, local `transform` and `skeleton`. Call this method during {@link _redraw}.
+   */
+  add_mesh(mesh: Mesh, material?: Material, transform?: Transform3D | Projection, skeleton?: SkinReference): void;
+  /**
+   * Adds an unscaled billboard for visualization and selection. Call this method during {@link _redraw}.
+   */
+  add_unscaled_billboard(material: Material, default_scale?: float, modulate?: Color): void;
+  /** Removes everything in the gizmo including meshes, collisions and handles. */
+  clear(): void;
+  /** Returns the {@link Node3D} node associated with this gizmo. */
+  get_node_3d(): Node3D | null;
+  /**
+   * Returns the {@link EditorNode3DGizmoPlugin} that owns this gizmo. It's useful to retrieve materials using {@link EditorNode3DGizmoPlugin.get_material}.
+   */
+  get_plugin(): EditorNode3DGizmoPlugin | null;
+  /**
+   * Returns a list of the currently selected subgizmos. Can be used to highlight selected elements during {@link _redraw}.
+   */
+  get_subgizmo_selection(): PackedInt32Array;
+  /**
+   * Returns `true` if the given subgizmo is currently selected. Can be used to highlight selected elements during {@link _redraw}.
+   */
+  is_subgizmo_selected(id: int): boolean;
+  /** Sets the gizmo's hidden state. If `true`, the gizmo will be hidden. If `false`, it will be shown. */
+  set_hidden(hidden: boolean): void;
+  /** Sets the reference {@link Node3D} node for the gizmo. `node` must inherit from {@link Node3D}. */
+  set_node_3d(node: Node): void;
+}

package/typings/classes/EditorNode3DGizmoPlugin.d.ts

@@ -0,0 +1,103 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A class used by the editor to define Node3D gizmo types. */
+declare class EditorNode3DGizmoPlugin extends Resource {
+  _begin_handle_action(gizmo: EditorNode3DGizmo, handle_id: int, secondary: boolean): void;
+  /**
+   * Override this method to define whether the gizmos handled by this plugin can be hidden or not. Returns `true` if not overridden.
+   */
+  _can_be_hidden(): boolean;
+  /**
+   * Override this method to commit a handle being edited (handles must have been previously added by {@link EditorNode3DGizmo.add_handles} during {@link _redraw}). This usually means creating an {@link UndoRedo} action for the change, using the current handle value as "do" and the `restore` argument as "undo".
+   * If the `cancel` argument is `true`, the `restore` value should be directly set, without any {@link UndoRedo} action.
+   * The `secondary` argument is `true` when the committed handle is secondary (see {@link EditorNode3DGizmo.add_handles} for more information).
+   * Called for this plugin's active gizmos.
+   */
+  _commit_handle(gizmo: EditorNode3DGizmo, handle_id: int, secondary: boolean, restore: unknown, cancel: boolean): void;
+  /**
+   * Override this method to commit a group of subgizmos being edited (see {@link _subgizmos_intersect_ray} and {@link _subgizmos_intersect_frustum}). This usually means creating an {@link UndoRedo} action for the change, using the current transforms as "do" and the `restores` transforms as "undo".
+   * If the `cancel` argument is `true`, the `restores` transforms should be directly set, without any {@link UndoRedo} action. As with all subgizmo methods, transforms are given in local space respect to the gizmo's Node3D. Called for this plugin's active gizmos.
+   */
+  _commit_subgizmos(gizmo: EditorNode3DGizmo, ids: PackedInt32Array | Array<unknown>, restores: Array<Transform3D>, cancel: boolean): void;
+  /**
+   * Override this method to return a custom {@link EditorNode3DGizmo} for the 3D nodes of your choice, return `null` for the rest of nodes. See also {@link _has_gizmo}.
+   */
+  _create_gizmo(for_node_3d: Node3D): EditorNode3DGizmo | null;
+  /** Override this method to provide the name that will appear in the gizmo visibility menu. */
+  _get_gizmo_name(): string;
+  /**
+   * Override this method to provide gizmo's handle names. The `secondary` argument is `true` when the requested handle is secondary (see {@link EditorNode3DGizmo.add_handles} for more information). Called for this plugin's active gizmos.
+   */
+  _get_handle_name(gizmo: EditorNode3DGizmo, handle_id: int, secondary: boolean): string;
+  /**
+   * Override this method to return the current value of a handle. This value will be requested at the start of an edit and used as the `restore` argument in {@link _commit_handle}.
+   * The `secondary` argument is `true` when the requested handle is secondary (see {@link EditorNode3DGizmo.add_handles} for more information).
+   * Called for this plugin's active gizmos.
+   */
+  _get_handle_value(gizmo: EditorNode3DGizmo, handle_id: int, secondary: boolean): unknown;
+  /**
+   * Override this method to set the gizmo's priority. Gizmos with higher priority will have precedence when processing inputs like handles or subgizmos selection.
+   * All built-in editor gizmos return a priority of `-1`. If not overridden, this method will return `0`, which means custom gizmos will automatically get higher priority than built-in gizmos.
+   */
+  _get_priority(): int;
+  /**
+   * Override this method to return the current transform of a subgizmo. As with all subgizmo methods, the transform should be in local space respect to the gizmo's Node3D. This transform will be requested at the start of an edit and used in the `restore` argument in {@link _commit_subgizmos}. Called for this plugin's active gizmos.
+   */
+  _get_subgizmo_transform(gizmo: EditorNode3DGizmo, subgizmo_id: int): Transform3D;
+  /**
+   * Override this method to define which Node3D nodes have a gizmo from this plugin. Whenever a {@link Node3D} node is added to a scene this method is called, if it returns `true` the node gets a generic {@link EditorNode3DGizmo} assigned and is added to this plugin's list of active gizmos.
+   */
+  _has_gizmo(for_node_3d: Node3D): boolean;
+  /**
+   * Override this method to return `true` whenever to given handle should be highlighted in the editor. The `secondary` argument is `true` when the requested handle is secondary (see {@link EditorNode3DGizmo.add_handles} for more information). Called for this plugin's active gizmos.
+   */
+  _is_handle_highlighted(gizmo: EditorNode3DGizmo, handle_id: int, secondary: boolean): boolean;
+  /**
+   * Override this method to define whether Node3D with this gizmo should be selectable even when the gizmo is hidden.
+   */
+  _is_selectable_when_hidden(): boolean;
+  /**
+   * Override this method to add all the gizmo elements whenever a gizmo update is requested. It's common to call {@link EditorNode3DGizmo.clear} at the beginning of this method and then add visual elements depending on the node's properties.
+   */
+  _redraw(gizmo: EditorNode3DGizmo): void;
+  /**
+   * Override this method to update the node's properties when the user drags a gizmo handle (previously added with {@link EditorNode3DGizmo.add_handles}). The provided `screen_pos` is the mouse position in screen coordinates and the `camera` can be used to convert it to raycasts.
+   * The `secondary` argument is `true` when the edited handle is secondary (see {@link EditorNode3DGizmo.add_handles} for more information).
+   * Called for this plugin's active gizmos.
+   */
+  _set_handle(gizmo: EditorNode3DGizmo, handle_id: int, secondary: boolean, camera: Camera3D, screen_pos: Vector2 | Vector2i): void;
+  /**
+   * Override this method to update the node properties during subgizmo editing (see {@link _subgizmos_intersect_ray} and {@link _subgizmos_intersect_frustum}). The `transform` is given in the Node3D's local coordinate system. Called for this plugin's active gizmos.
+   */
+  _set_subgizmo_transform(gizmo: EditorNode3DGizmo, subgizmo_id: int, transform: Transform3D | Projection): void;
+  /**
+   * Override this method to allow selecting subgizmos using mouse drag box selection. Given a `camera` and `frustum_planes`, this method should return which subgizmos are contained within the frustums. The `frustum_planes` argument consists of an array with all the {@link Plane}s that make up the selection frustum. The returned value should contain a list of unique subgizmo identifiers, these identifiers can have any non-negative value and will be used in other virtual methods like {@link _get_subgizmo_transform} or {@link _commit_subgizmos}. Called for this plugin's active gizmos.
+   */
+  _subgizmos_intersect_frustum(gizmo: EditorNode3DGizmo, camera: Camera3D, frustum_planes: Array<Plane>): PackedInt32Array;
+  /**
+   * Override this method to allow selecting subgizmos using mouse clicks. Given a `camera` and a `screen_pos` in screen coordinates, this method should return which subgizmo should be selected. The returned value should be a unique subgizmo identifier, which can have any non-negative value and will be used in other virtual methods like {@link _get_subgizmo_transform} or {@link _commit_subgizmos}. Called for this plugin's active gizmos.
+   */
+  _subgizmos_intersect_ray(gizmo: EditorNode3DGizmo, camera: Camera3D, screen_pos: Vector2 | Vector2i): int;
+  /**
+   * Adds a new material to the internal material list for the plugin. It can then be accessed with {@link get_material}. Should not be overridden.
+   */
+  add_material(name: string | NodePath, material: StandardMaterial3D): void;
+  /**
+   * Creates a handle material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with {@link get_material} and used in {@link EditorNode3DGizmo.add_handles}. Should not be overridden.
+   * You can optionally provide a texture to use instead of the default icon.
+   */
+  create_handle_material(name: string | NodePath, billboard?: boolean, texture?: Texture2D): void;
+  /**
+   * Creates an icon material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with {@link get_material} and used in {@link EditorNode3DGizmo.add_unscaled_billboard}. Should not be overridden.
+   */
+  create_icon_material(name: string | NodePath, texture: Texture2D, on_top?: boolean, color?: Color): void;
+  /**
+   * Creates an unshaded material with its variants (selected and/or editable) and adds them to the internal material list. They can then be accessed with {@link get_material} and used in {@link EditorNode3DGizmo.add_mesh} and {@link EditorNode3DGizmo.add_lines}. Should not be overridden.
+   */
+  create_material(name: string | NodePath, color: Color, billboard?: boolean, on_top?: boolean, use_vertex_color?: boolean): void;
+  /**
+   * Gets material from the internal list of materials. If an {@link EditorNode3DGizmo} is provided, it will try to get the corresponding variant (selected and/or editable).
+   */
+  get_material(name: string | NodePath, gizmo?: EditorNode3DGizmo): StandardMaterial3D | null;
+}

package/typings/classes/EditorPaths.d.ts

@@ -0,0 +1,52 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Editor-only singleton that returns paths to various OS-specific data folders and files. */
+declare class EditorPaths extends GodotObject {
+  /**
+   * Returns the absolute path to the user's cache folder. This folder should be used for temporary data that can be removed safely whenever the editor is closed (such as generated resource thumbnails).
+   * **Default paths per platform:**
+   * [codeblock lang=text]
+   * - Windows: %LOCALAPPDATA%\Godot\
+   * - macOS: ~/Library/Caches/Godot/
+   * - Linux: ~/.cache/godot/
+   * [/codeblock]
+   */
+  get_cache_dir(): string;
+  /**
+   * Returns the absolute path to the user's configuration folder. This folder should be used for *persistent* user configuration files.
+   * **Default paths per platform:**
+   * [codeblock lang=text]
+   * - Windows: %APPDATA%\Godot\                    (same as `get_data_dir()`)
+   * - macOS: ~/Library/Application Support/Godot/  (same as `get_data_dir()`)
+   * - Linux: ~/.config/godot/
+   * [/codeblock]
+   */
+  get_config_dir(): string;
+  /**
+   * Returns the absolute path to the user's data folder. This folder should be used for *persistent* user data files such as installed export templates.
+   * **Default paths per platform:**
+   * [codeblock lang=text]
+   * - Windows: %APPDATA%\Godot\                    (same as `get_config_dir()`)
+   * - macOS: ~/Library/Application Support/Godot/  (same as `get_config_dir()`)
+   * - Linux: ~/.local/share/godot/
+   * [/codeblock]
+   */
+  get_data_dir(): string;
+  /**
+   * Returns the relative path to the editor settings for this project. This is usually `"res://.godot/editor"`. Projects all have a unique subdirectory inside the settings path where project-specific editor settings are saved.
+   */
+  get_project_settings_dir(): string;
+  /**
+   * Returns the absolute path to the self-contained file that makes the current Godot editor instance be considered as self-contained. Returns an empty string if the current Godot editor instance isn't self-contained. See also {@link is_self_contained}.
+   */
+  get_self_contained_file(): string;
+  /**
+   * Returns `true` if the editor is marked as self-contained, `false` otherwise. When self-contained mode is enabled, user configuration, data and cache files are saved in an `editor_data/` folder next to the editor binary. This makes portable usage easier and ensures the Godot editor minimizes file writes outside its own folder. Self-contained mode is not available for exported projects.
+   * Self-contained mode can be enabled by creating a file named `._sc_` or `_sc_` in the same folder as the editor binary or macOS .app bundle while the editor is not running. See also {@link get_self_contained_file}.
+   * **Note:** On macOS, quarantine flag should be manually removed before using self-contained mode, see Running on macOS (https://docs.godotengine.org/en/stable/tutorials/export/running_on_macos.html).
+   * **Note:** On macOS, placing `_sc_` or any other file inside .app bundle will break digital signature and make it non-portable, consider placing it in the same folder as the .app bundle instead.
+   * **Note:** The Steam release of Godot uses self-contained mode by default.
+   */
+  is_self_contained(): boolean;
+}