typescript-to-gdscript 0.1.0

package/typings/classes/DrawableTexture2D.d.ts

@@ -0,0 +1,47 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D texture that supports drawing to itself via Blit calls. */
+declare class DrawableTexture2D extends Texture2D {
+  resource_local_to_scene: boolean;
+
+  /**
+   * Draws to given `rect` on this texture by copying from the given `source`. A `modulate` color can be passed in for the shader to use, but defaults to White. The `mipmap` value can specify a draw to a lower mipmap level. The `material` parameter can take a ShaderMaterial with a TextureBlit Shader for custom drawing behavior.
+   */
+  blit_rect(rect: Rect2i | Rect2, source: Texture2D, modulate?: Color, mipmap?: int, material?: Material): void;
+  /**
+   * Draws to the given `rect` on this texture, as well as on up to 3 DrawableTexture `extra_targets`. All `extra_targets` must be the same size and DrawableFormat as the original target, otherwise the Shader may fail. Expects up to 4 Texture `sources`, but will replace missing `sources` with default Black Textures.
+   */
+  blit_rect_multi(rect: Rect2i | Rect2, sources: Array<Texture2D>, extra_targets: Array<DrawableTexture2D>, modulate?: Color, mipmap?: int, material?: Material): void;
+  /** Re-calculates the mipmaps for this texture on demand. */
+  generate_mipmaps(): void;
+  /** Returns `true` if mipmaps are set to be used on this DrawableTexture. */
+  get_use_mipmaps(): boolean;
+  /** Sets the format of this DrawableTexture. */
+  set_format(format: int): void;
+  /** Sets the height of this DrawableTexture. */
+  set_height(height: int): void;
+  /** Sets if mipmaps should be used on this DrawableTexture. */
+  set_use_mipmaps(mipmaps: boolean): void;
+  /** Sets the width of this DrawableTexture. */
+  set_width(width: int): void;
+  /** Initializes the DrawableTexture to a White texture of the given `width`, `height`, and `format`. */
+  setup(width: int, height: int, format: int, color?: Color, use_mipmaps?: boolean): void;
+
+  // enum DrawableFormat
+  /** OpenGL texture format RGBA with four components, each with a bitdepth of 8. */
+  static readonly DRAWABLE_FORMAT_RGBA8: int;
+  /**
+   * OpenGL texture format RGBA with four components, each with a bitdepth of 8.
+   * When drawn to, an sRGB to linear color space conversion is performed.
+   */
+  static readonly DRAWABLE_FORMAT_RGBA8_SRGB: int;
+  /**
+   * OpenGL texture format GL_RGBA16F where there are four components, each a 16-bit "half-precision" floating-point value.
+   */
+  static readonly DRAWABLE_FORMAT_RGBAH: int;
+  /**
+   * OpenGL texture format GL_RGBA32F where there are four components, each a 32-bit floating-point value.
+   */
+  static readonly DRAWABLE_FORMAT_RGBAF: int;
+}

package/typings/classes/EditorCommandPalette.d.ts

@@ -0,0 +1,21 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Godot editor's command palette. */
+declare class EditorCommandPalette extends ConfirmationDialog {
+  dialog_hide_on_ok: boolean;
+
+  /**
+   * Adds a custom command to EditorCommandPalette.
+   * - `command_name`: {@link String} (Name of the **Command**. This is displayed to the user.)
+   * - `key_name`: {@link String} (Name of the key for a particular **Command**. This is used to uniquely identify the **Command**.)
+   * - `binded_callable`: {@link Callable} (Callable of the **Command**. This will be executed when the **Command** is selected.)
+   * - `shortcut_text`: {@link String} (Shortcut text of the **Command** if available.)
+   */
+  add_command(command_name: string | NodePath, key_name: string | NodePath, binded_callable: Callable, shortcut_text?: string | NodePath): void;
+  /**
+   * Removes the custom command from EditorCommandPalette.
+   * - `key_name`: {@link String} (Name of the key for a particular **Command**.)
+   */
+  remove_command(key_name: string | NodePath): void;
+}

package/typings/classes/EditorContextMenuPlugin.d.ts

@@ -0,0 +1,59 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Plugin for adding custom context menus in the editor. */
+declare class EditorContextMenuPlugin extends RefCounted {
+  /**
+   * Called when creating a context menu, custom options can be added by using the {@link add_context_menu_item} or {@link add_context_menu_item_from_shortcut} functions. `paths` contains currently selected paths (depending on menu), which can be used to conditionally add options.
+   */
+  _popup_menu(paths: PackedStringArray | Array<unknown>): void;
+  /**
+   * Add custom option to the context menu of the plugin's specified slot. When the option is activated, `callback` will be called. Callback should take single {@link Array} argument; array contents depend on context menu slot.
+   * If you want to assign shortcut to the menu item, use {@link add_context_menu_item_from_shortcut} instead.
+   */
+  add_context_menu_item(name: string | NodePath, callback: Callable, icon?: Texture2D): void;
+  /**
+   * Add custom option to the context menu of the plugin's specified slot. The option will have the `shortcut` assigned and reuse its callback. The shortcut has to be registered beforehand with {@link add_menu_shortcut}.
+   */
+  add_context_menu_item_from_shortcut(name: string | NodePath, shortcut: Shortcut, icon?: Texture2D): void;
+  /**
+   * Add a submenu to the context menu of the plugin's specified slot. The submenu is not automatically handled, you need to connect to its signals yourself. Also the submenu is freed on every popup, so provide a new {@link PopupMenu} every time.
+   */
+  add_context_submenu_item(name: string | NodePath, menu: PopupMenu, icon?: Texture2D): void;
+  /**
+   * Registers a shortcut associated with the plugin's context menu. This method should be called once (e.g. in plugin's {@link Object._init}). `callback` will be called when user presses the specified `shortcut` while the menu's context is in effect (e.g. FileSystem dock is focused). Callback should take single {@link Array} argument; array contents depend on context menu slot.
+   */
+  add_menu_shortcut(shortcut: Shortcut, callback: Callable): void;
+
+  // enum ContextMenuSlot
+  /**
+   * Context menu of Scene dock. {@link _popup_menu} will be called with a list of paths to currently selected nodes, while option callback will receive the list of currently selected nodes.
+   */
+  static readonly CONTEXT_SLOT_SCENE_TREE: int;
+  /**
+   * Context menu of FileSystem dock. {@link _popup_menu} and option callback will be called with list of paths of the currently selected files.
+   */
+  static readonly CONTEXT_SLOT_FILESYSTEM: int;
+  /**
+   * Context menu of Script editor's script tabs. {@link _popup_menu} will be called with the path to the currently edited script, while option callback will receive reference to that script.
+   */
+  static readonly CONTEXT_SLOT_SCRIPT_EDITOR: int;
+  /**
+   * The "Create..." submenu of FileSystem dock's context menu, or the "New" section of the main context menu when empty space is clicked. {@link _popup_menu} and option callback will be called with the path of the currently selected folder. When clicking the empty space, the list of paths for popup method will be empty.
+   */
+  static readonly CONTEXT_SLOT_FILESYSTEM_CREATE: int;
+  /**
+   * Context menu of Script editor's code editor. {@link _popup_menu} will be called with the path to the {@link CodeEdit} node. You can fetch it using this code:
+   * The option callback will receive reference to that node. You can use {@link CodeEdit} methods to perform symbol lookups etc.
+   */
+  static readonly CONTEXT_SLOT_SCRIPT_EDITOR_CODE: int;
+  /**
+   * Context menu of scene tabs. {@link _popup_menu} will be called with the path of the clicked scene, or empty {@link PackedStringArray} if the menu was opened on empty space. The option callback will receive the path of the clicked scene, or empty {@link String} if none was clicked.
+   */
+  static readonly CONTEXT_SLOT_SCENE_TABS: int;
+  /**
+   * Context menu of 2D editor's basic right-click menu. {@link _popup_menu} will be called with paths to all {@link CanvasItem} nodes under the cursor. You can fetch them using this code:
+   * The paths array is empty if there weren't any nodes under cursor. The option callback will receive a typed array of {@link CanvasItem} nodes.
+   */
+  static readonly CONTEXT_SLOT_2D_EDITOR: int;
+}

package/typings/classes/EditorDebuggerPlugin.d.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A base class to implement debugger plugins. */
+declare class EditorDebuggerPlugin extends RefCounted {
+  /** Override this method to be notified when a breakpoint is set in the editor. */
+  _breakpoint_set_in_tree(script: Script, line: int, enabled: boolean): void;
+  /** Override this method to be notified when all breakpoints are cleared in the editor. */
+  _breakpoints_cleared_in_tree(): void;
+  /**
+   * Override this method to process incoming messages. The `session_id` is the ID of the {@link EditorDebuggerSession} that received the `message`. Use {@link get_session} to retrieve the session. This method should return `true` if the message is recognized.
+   */
+  _capture(message: string | NodePath, data: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array, session_id: int): boolean;
+  /**
+   * Override this method to be notified when a breakpoint line has been clicked in the debugger breakpoint panel.
+   */
+  _goto_script_line(script: Script, line: int): void;
+  /**
+   * Override this method to enable receiving messages from the debugger. If `capture` is "my_message" then messages starting with "my_message:" will be passed to the {@link _capture} method.
+   */
+  _has_capture(capture: string | NodePath): boolean;
+  /**
+   * Override this method to be notified whenever a new {@link EditorDebuggerSession} is created. Note that the session may be inactive during this stage.
+   */
+  _setup_session(session_id: int): void;
+  /** Returns the {@link EditorDebuggerSession} with the given `id`. */
+  get_session(id: int): EditorDebuggerSession | null;
+  /**
+   * Returns an array of {@link EditorDebuggerSession} currently available to this debugger plugin.
+   * **Note:** Sessions in the array may be inactive, check their state via {@link EditorDebuggerSession.is_active}.
+   */
+  get_sessions(): Array<unknown>;
+}

package/typings/classes/EditorDebuggerSession.d.ts

@@ -0,0 +1,41 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A class to interact with the editor debugger. */
+declare class EditorDebuggerSession extends RefCounted {
+  /**
+   * Adds the given `control` to the debug session UI in the debugger bottom panel. The `control`'s node name will be used as the tab title.
+   */
+  add_session_tab(control: Control): void;
+  /** Returns `true` if the debug session is currently attached to a remote instance. */
+  is_active(): boolean;
+  /** Returns `true` if the attached remote instance is currently in the debug loop. */
+  is_breaked(): boolean;
+  /** Returns `true` if the attached remote instance can be debugged. */
+  is_debuggable(): boolean;
+  /** Removes the given `control` from the debug session UI in the debugger bottom panel. */
+  remove_session_tab(control: Control): void;
+  /**
+   * Sends the given `message` to the attached remote instance, optionally passing additionally `data`. See {@link EngineDebugger} for how to retrieve those messages.
+   */
+  send_message(message: string | NodePath, data?: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  /**
+   * Enables or disables a specific breakpoint based on `enabled`, updating the Editor Breakpoint Panel accordingly.
+   */
+  set_breakpoint(path: string | NodePath, line: int, enabled: boolean): void;
+  /**
+   * Toggle the given `profiler` on the attached remote instance, optionally passing additionally `data`. See {@link EngineProfiler} for more details.
+   */
+  toggle_profiler(profiler: string | NodePath, enable: boolean, data?: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+
+  /**
+   * Emitted when the attached remote instance enters a break state. If `can_debug` is `true`, the remote instance will enter the debug loop.
+   */
+  breaked: Signal<[boolean]>;
+  /** Emitted when the attached remote instance exits a break state. */
+  continued: Signal<[]>;
+  /** Emitted when a remote instance is attached to this session (i.e. the session becomes active). */
+  started: Signal<[]>;
+  /** Emitted when a remote instance is detached from this session (i.e. the session becomes inactive). */
+  stopped: Signal<[]>;
+}

package/typings/classes/EditorDock.d.ts

@@ -0,0 +1,141 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Dockable container for the editor. */
+declare class EditorDock extends MarginContainer {
+  /**
+   * The available layouts for this dock, as a bitmask. By default, the dock allows vertical and floating layouts.
+   */
+  available_layouts: int;
+  /**
+   * If `true`, the dock can be closed with the Close button in the context popup. Docks with {@link global} enabled are always closable.
+   */
+  closable: boolean;
+  /**
+   * The default dock slot used when adding the dock with {@link EditorPlugin.add_dock}.
+   * After the dock is added, it can be moved to a different slot and the editor will automatically remember its position between sessions. If you remove and re-add the dock, it will be reset to default.
+   */
+  default_slot: int;
+  /** The icon for the dock, as a texture. If specified, it will override {@link icon_name}. */
+  dock_icon: Texture2D | null;
+  /** The shortcut used to open the dock. */
+  dock_shortcut: Shortcut | null;
+  /**
+   * If `true`, the dock will always display an icon, regardless of {@link EditorSettings.interface/editor/docks/dock_tab_style} or {@link EditorSettings.interface/editor/docks/bottom_dock_tab_style}.
+   */
+  force_show_icon: boolean;
+  /**
+   * If `true`, the dock appears in the **Editor > Editor Docks** menu and can be closed. Non-global docks can still be closed using {@link close} or when {@link closable} is `true`.
+   */
+  global: boolean;
+  /**
+   * The icon for the dock, as a name from the `EditorIcons` theme type in the editor theme. You can find the list of available icons here (https://godot-editor-icons.github.io/).
+   */
+  icon_name: string;
+  /**
+   * The key representing this dock in the editor's layout file. If empty, the dock's displayed name will be used instead.
+   */
+  layout_key: string;
+  /**
+   * The title of the dock's tab. If empty, the dock's {@link Node.name} will be used. If the name is auto-generated (contains `@`), the first child's name will be used instead.
+   */
+  title: string;
+  /** The color of the dock tab's title. If its alpha is `0.0`, the default font color will be used. */
+  title_color: Color;
+  /**
+   * If `true`, the dock is not automatically opened or closed when loading an editor layout, only moved. It also can't be opened using a shortcut. This is meant for docks that are opened and closed in specific cases, such as when selecting a {@link TileMap} or {@link AnimationTree} node.
+   */
+  transient: boolean;
+  set_available_layouts(value: int): void;
+  get_available_layouts(): int;
+  set_closable(value: boolean): void;
+  is_closable(): boolean;
+  set_default_slot(value: int): void;
+  get_default_slot(): int;
+  set_dock_icon(value: Texture2D | null): void;
+  get_dock_icon(): Texture2D | null;
+  set_dock_shortcut(value: Shortcut | null): void;
+  get_dock_shortcut(): Shortcut | null;
+  set_force_show_icon(value: boolean): void;
+  get_force_show_icon(): boolean;
+  set_global(value: boolean): void;
+  is_global(): boolean;
+  set_icon_name(value: string): void;
+  get_icon_name(): string;
+  set_layout_key(value: string | NodePath): void;
+  get_layout_key(): string;
+  set_title(value: string | NodePath): void;
+  get_title(): string;
+  set_title_color(value: Color): void;
+  get_title_color(): Color;
+  set_transient(value: boolean): void;
+  is_transient(): boolean;
+
+  /**
+   * Implement this method to handle loading this dock's layout. It's equivalent to {@link EditorPlugin._set_window_layout}. `section` is a unique section based on {@link layout_key}.
+   */
+  _load_layout_from_config(config: ConfigFile, section: string | NodePath): void;
+  /**
+   * Implement this method to handle saving this dock's layout. It's equivalent to {@link EditorPlugin._get_window_layout}. `section` is a unique section based on {@link layout_key}.
+   */
+  _save_layout_to_config(config: ConfigFile, section: string | NodePath): void;
+  /**
+   * Implement this method to handle the layout switching for this dock. `layout` is one of the {@link DockLayout} constants.
+   */
+  _update_layout(layout: int): void;
+  /** Closes the dock, making its tab hidden. */
+  close(): void;
+  /**
+   * Focuses the dock's tab (or window if it's floating). If the dock was closed, it will be opened. If it's a bottom dock, makes the bottom panel visible.
+   */
+  make_visible(): void;
+  /**
+   * Opens the dock. It will appear in the last used dock slot. If the dock has no default slot, it will be opened floating.
+   * **Note:** This does not focus the dock. If you want to open and focus the dock, use {@link make_visible}.
+   */
+  open(): void;
+
+  /**
+   * Emitted when the dock is closed with the Close button in the context popup, before it's removed from its parent. See {@link closable}.
+   */
+  closed: Signal<[]>;
+  /** Emitted when the dock is opened via the Editor > Editor Docks menu, before it's made visible. */
+  opened: Signal<[]>;
+
+  // enum DockLayout
+  /** Allows placing the dock in the vertical dock slots on either side of the editor. */
+  static readonly DOCK_LAYOUT_VERTICAL: int;
+  /** Allows placing the dock in the horizontal dock slots at the bottom. */
+  static readonly DOCK_LAYOUT_HORIZONTAL: int;
+  /** Allows making the dock floating (opened as a separate window). */
+  static readonly DOCK_LAYOUT_FLOATING: int;
+  /** Allows placing the dock in all available slots. */
+  static readonly DOCK_LAYOUT_ALL: int;
+  // enum DockSlot
+  /** The dock is closed. */
+  static readonly DOCK_SLOT_NONE: int;
+  /** Dock slot, left side, upper-left (empty in default layout). */
+  static readonly DOCK_SLOT_LEFT_UL: int;
+  /** Dock slot, left side, bottom-left (empty in default layout). */
+  static readonly DOCK_SLOT_LEFT_BL: int;
+  /** Dock slot, left side, upper-right (in default layout includes Scene and Import docks). */
+  static readonly DOCK_SLOT_LEFT_UR: int;
+  /** Dock slot, left side, bottom-right (in default layout includes FileSystem and History docks). */
+  static readonly DOCK_SLOT_LEFT_BR: int;
+  /** Dock slot, right side, upper-left (in default layout includes Inspector, Signal, and Group docks). */
+  static readonly DOCK_SLOT_RIGHT_UL: int;
+  /** Dock slot, right side, bottom-left (empty in default layout). */
+  static readonly DOCK_SLOT_RIGHT_BL: int;
+  /** Dock slot, right side, upper-right (empty in default layout). */
+  static readonly DOCK_SLOT_RIGHT_UR: int;
+  /** Dock slot, right side, bottom-right (empty in default layout). */
+  static readonly DOCK_SLOT_RIGHT_BR: int;
+  /** Bottom panel. */
+  static readonly DOCK_SLOT_BOTTOM: int;
+  /** Dock slot at the bottom, below bottom panel, on the left side. */
+  static readonly DOCK_SLOT_BOTTOM_L: int;
+  /** Dock slot at the bottom, below bottom panel, on the right side. */
+  static readonly DOCK_SLOT_BOTTOM_R: int;
+  /** Represents the size of the {@link DockSlot} enum. */
+  static readonly DOCK_SLOT_MAX: int;
+}

package/typings/classes/EditorExportPlatform.d.ts

@@ -0,0 +1,125 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Identifies a supported export platform, and internally provides the functionality of exporting to that platform.
+ */
+declare class EditorExportPlatform extends RefCounted {
+  /** Adds a message to the export log that will be displayed when exporting ends. */
+  add_message(type_: int, category: string | NodePath, message: string | NodePath): void;
+  /** Clears the export log. */
+  clear_messages(): void;
+  /** Create a new preset for this platform. */
+  create_preset(): EditorExportPreset;
+  /** Creates a PCK archive at `path` for the specified `preset`. */
+  export_pack(preset: EditorExportPreset, debug: boolean, path: string | NodePath, flags: int): int;
+  /**
+   * Creates a patch PCK archive at `path` for the specified `preset`, containing only the files that have changed since the last patch.
+   * **Note:** `patches` is an optional override of the set of patches defined in the export preset. When empty the patches defined in the export preset will be used instead.
+   */
+  export_pack_patch(preset: EditorExportPreset, debug: boolean, path: string | NodePath, patches?: PackedStringArray | Array<unknown>, flags?: int): int;
+  /** Creates a full project at `path` for the specified `preset`. */
+  export_project(preset: EditorExportPreset, debug: boolean, path: string | NodePath, flags: int): int;
+  /**
+   * Exports project files for the specified preset. This method can be used to implement custom export format, other than PCK and ZIP. One of the callbacks is called for each exported file.
+   * `save_cb` is called for all exported files and have the following arguments: `file_path: String`, `file_data: PackedByteArray`, `file_index: int`, `file_count: int`, `encryption_include_filters: PackedStringArray`, `encryption_exclude_filters: PackedStringArray`, `encryption_key: PackedByteArray`.
+   * `shared_cb` is called for exported native shared/static libraries and have the following arguments: `file_path: String`, `tags: PackedStringArray`, `target_folder: String`.
+   * **Note:** `file_index` and `file_count` are intended for progress tracking only and aren't necessarily unique and precise.
+   */
+  export_project_files(preset: EditorExportPreset, debug: boolean, save_cb: Callable, shared_cb?: Callable): int;
+  /** Create a ZIP archive at `path` for the specified `preset`. */
+  export_zip(preset: EditorExportPreset, debug: boolean, path: string | NodePath, flags: int): int;
+  /**
+   * Create a patch ZIP archive at `path` for the specified `preset`, containing only the files that have changed since the last patch.
+   * **Note:** `patches` is an optional override of the set of patches defined in the export preset. When empty the patches defined in the export preset will be used instead.
+   */
+  export_zip_patch(preset: EditorExportPreset, debug: boolean, path: string | NodePath, patches?: PackedStringArray | Array<unknown>, flags?: int): int;
+  /**
+   * Locates export template for the platform, and returns {@link Dictionary} with the following keys: `path: String` and `error: String`. This method is provided for convenience and custom export platforms aren't required to use it or keep export templates stored in the same way official templates are.
+   */
+  find_export_template(template_file_name: string | NodePath): Dictionary;
+  /**
+   * Generates array of command line arguments for the default export templates for the debug flags and editor settings.
+   */
+  gen_export_flags(flags: int): PackedStringArray;
+  /** Returns array of {@link EditorExportPreset}s for this platform. */
+  get_current_presets(): Array<unknown>;
+  /** Returns array of core file names that always should be exported regardless of preset config. */
+  static get_forced_export_files(preset?: EditorExportPreset): PackedStringArray;
+  /**
+   * Returns additional files that should always be exported regardless of preset configuration, and are not part of the project source. The returned {@link Dictionary} contains filename keys ({@link String}) and their corresponding raw data ({@link PackedByteArray}).
+   */
+  get_internal_export_files(preset: EditorExportPreset, debug: boolean): Dictionary;
+  /** Returns the message category for the message with the given `index`. */
+  get_message_category(index: int): string;
+  /** Returns the number of messages in the export log. */
+  get_message_count(): int;
+  /** Returns the text for the message with the given `index`. */
+  get_message_text(index: int): string;
+  /** Returns the type for the message with the given `index`. */
+  get_message_type(index: int): int;
+  /**
+   * Returns the name of the export operating system handled by this {@link EditorExportPlatform} class, as a friendly string. Possible return values are `Windows`, `Linux`, `macOS`, `Android`, `iOS`, and `Web`.
+   */
+  get_os_name(): string;
+  /** Returns most severe message type currently present in the export log. */
+  get_worst_message_type(): int;
+  /**
+   * Saves PCK archive and returns {@link Dictionary} with the following keys: `result: Error`, `so_files: Array` (array of the shared/static objects which contains dictionaries with the following keys: `path: String`, `tags: PackedStringArray`, and `target_folder: String`).
+   * If `embed` is `true`, PCK content is appended to the end of `path` file and return {@link Dictionary} additionally include following keys: `embedded_start: int` (embedded PCK offset) and `embedded_size: int` (embedded PCK size).
+   */
+  save_pack(preset: EditorExportPreset, debug: boolean, path: string | NodePath, embed?: boolean): Dictionary;
+  /**
+   * Saves patch PCK archive and returns {@link Dictionary} with the following keys: `result: Error`, `so_files: Array` (array of the shared/static objects which contains dictionaries with the following keys: `path: String`, `tags: PackedStringArray`, and `target_folder: String`).
+   */
+  save_pack_patch(preset: EditorExportPreset, debug: boolean, path: string | NodePath): Dictionary;
+  /**
+   * Saves ZIP archive and returns {@link Dictionary} with the following keys: `result: Error`, `so_files: Array` (array of the shared/static objects which contains dictionaries with the following keys: `path: String`, `tags: PackedStringArray`, and `target_folder: String`).
+   */
+  save_zip(preset: EditorExportPreset, debug: boolean, path: string | NodePath): Dictionary;
+  /**
+   * Saves patch ZIP archive and returns {@link Dictionary} with the following keys: `result: Error`, `so_files: Array` (array of the shared/static objects which contains dictionaries with the following keys: `path: String`, `tags: PackedStringArray`, and `target_folder: String`).
+   */
+  save_zip_patch(preset: EditorExportPreset, debug: boolean, path: string | NodePath): Dictionary;
+  /** Uploads specified file over SCP protocol to the remote host. */
+  ssh_push_to_remote(host: string | NodePath, port: string | NodePath, scp_args: PackedStringArray | Array<unknown>, src_file: string | NodePath, dst_file: string | NodePath): int;
+  /**
+   * Executes specified command on the remote host via SSH protocol and returns command output in the `output`.
+   */
+  ssh_run_on_remote(host: string | NodePath, port: string | NodePath, ssh_arg: PackedStringArray | Array<unknown>, cmd_args: string | NodePath, output?: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array, port_fwd?: int): int;
+  /**
+   * Executes specified command on the remote host via SSH protocol and returns process ID (on the remote host) without waiting for command to finish.
+   */
+  ssh_run_on_remote_no_wait(host: string | NodePath, port: string | NodePath, ssh_args: PackedStringArray | Array<unknown>, cmd_args: string | NodePath, port_fwd?: int): int;
+
+  // enum ExportMessageType
+  /** Invalid message type used as the default value when no type is specified. */
+  static readonly EXPORT_MESSAGE_NONE: int;
+  /** Message type for informational messages that have no effect on the export. */
+  static readonly EXPORT_MESSAGE_INFO: int;
+  /** Message type for warning messages that should be addressed but still allow to complete the export. */
+  static readonly EXPORT_MESSAGE_WARNING: int;
+  /** Message type for error messages that must be addressed and fail the export. */
+  static readonly EXPORT_MESSAGE_ERROR: int;
+  // enum DebugFlags
+  /**
+   * Flag is set if the remotely debugged project is expected to use the remote file system. If set, {@link gen_export_flags} will append `--remote-fs` and `--remote-fs-password` (if {@link EditorSettings.filesystem/file_server/password} is defined) command line arguments to the returned list.
+   */
+  static readonly DEBUG_FLAG_DUMB_CLIENT: int;
+  /**
+   * Flag is set if remote debug is enabled. If set, {@link gen_export_flags} will append `--remote-debug` and `--breakpoints` (if breakpoints are selected in the script editor or added by the plugin) command line arguments to the returned list.
+   */
+  static readonly DEBUG_FLAG_REMOTE_DEBUG: int;
+  /**
+   * Flag is set if remotely debugged project is running on the localhost. If set, {@link gen_export_flags} will use `localhost` instead of {@link EditorSettings.network/debug/remote_host} as remote debugger host.
+   */
+  static readonly DEBUG_FLAG_REMOTE_DEBUG_LOCALHOST: int;
+  /**
+   * Flag is set if the "Visible Collision Shapes" remote debug option is enabled. If set, {@link gen_export_flags} will append the `--debug-collisions` command line argument to the returned list.
+   */
+  static readonly DEBUG_FLAG_VIEW_COLLISIONS: int;
+  /**
+   * Flag is set if the "Visible Navigation" remote debug option is enabled. If set, {@link gen_export_flags} will append the `--debug-navigation` command line argument to the returned list.
+   */
+  static readonly DEBUG_FLAG_VIEW_NAVIGATION: int;
+}

package/typings/classes/EditorExportPlatformAppleEmbedded.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for the Apple embedded platform exporters (iOS and visionOS). */
+declare class EditorExportPlatformAppleEmbedded extends EditorExportPlatform {
+}

package/typings/classes/EditorExportPlatformExtension.d.ts

@@ -0,0 +1,131 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for custom {@link EditorExportPlatform} implementations (plugins). */
+declare class EditorExportPlatformExtension extends EditorExportPlatform {
+  /**
+   * Returns `true` if the specified `preset` is valid and can be exported. Use {@link set_config_error} and {@link set_config_missing_templates} to set error details.
+   * Usual implementations call {@link _has_valid_export_configuration} and {@link _has_valid_project_configuration} to determine if exporting is possible.
+   */
+  _can_export(preset: EditorExportPreset, debug: boolean): boolean;
+  /** Called by the editor before platform is unregistered. */
+  _cleanup(): void;
+  /**
+   * Creates a PCK archive at `path` for the specified `preset`.
+   * This method is called when "Export PCK/ZIP" button is pressed in the export dialog, with "Export as Patch" disabled, and PCK is selected as a file type.
+   */
+  _export_pack(preset: EditorExportPreset, debug: boolean, path: string | NodePath, flags: int): int;
+  /**
+   * Creates a patch PCK archive at `path` for the specified `preset`, containing only the files that have changed since the last patch.
+   * This method is called when "Export PCK/ZIP" button is pressed in the export dialog, with "Export as Patch" enabled, and PCK is selected as a file type.
+   * **Note:** The patches provided in `patches` have already been loaded when this method is called and are merely provided as context. When empty the patches defined in the export preset have been loaded instead.
+   */
+  _export_pack_patch(preset: EditorExportPreset, debug: boolean, path: string | NodePath, patches: PackedStringArray | Array<unknown>, flags: int): int;
+  /**
+   * Creates a full project at `path` for the specified `preset`.
+   * This method is called when "Export" button is pressed in the export dialog.
+   * This method implementation can call {@link EditorExportPlatform.save_pack} or {@link EditorExportPlatform.save_zip} to use default PCK/ZIP export process, or calls {@link EditorExportPlatform.export_project_files} and implement custom callback for processing each exported file.
+   */
+  _export_project(preset: EditorExportPreset, debug: boolean, path: string | NodePath, flags: int): int;
+  /**
+   * Create a ZIP archive at `path` for the specified `preset`.
+   * This method is called when "Export PCK/ZIP" button is pressed in the export dialog, with "Export as Patch" disabled, and ZIP is selected as a file type.
+   */
+  _export_zip(preset: EditorExportPreset, debug: boolean, path: string | NodePath, flags: int): int;
+  /**
+   * Create a ZIP archive at `path` for the specified `preset`, containing only the files that have changed since the last patch.
+   * This method is called when "Export PCK/ZIP" button is pressed in the export dialog, with "Export as Patch" enabled, and ZIP is selected as a file type.
+   * **Note:** The patches provided in `patches` have already been loaded when this method is called and are merely provided as context. When empty the patches defined in the export preset have been loaded instead.
+   */
+  _export_zip_patch(preset: EditorExportPreset, debug: boolean, path: string | NodePath, patches: PackedStringArray | Array<unknown>, flags: int): int;
+  /** Returns array of supported binary extensions for the full project export. */
+  _get_binary_extensions(preset: EditorExportPreset): PackedStringArray;
+  /** Returns protocol used for remote debugging. Default implementation return `tcp://`. */
+  _get_debug_protocol(): string;
+  /** Returns device architecture for one-click deploy. */
+  _get_device_architecture(device: int): string;
+  /**
+   * Validates `option` and returns visibility for the specified `preset`. Default implementation return `true` for all options.
+   */
+  _get_export_option_visibility(preset: EditorExportPreset, option: string | NodePath): boolean;
+  /**
+   * Validates `option` and returns warning message for the specified `preset`. Default implementation return empty string for all options.
+   */
+  _get_export_option_warning(preset: EditorExportPreset, option: string): string;
+  /**
+   * Returns a property list, as an {@link Array} of dictionaries. Each {@link Dictionary} must at least contain the `name: StringName` and `type: Variant.Type` entries.
+   * Additionally, the following keys are supported:
+   * - `hint: PropertyHint`
+   * - `hint_string: String`
+   * - `usage: PropertyUsageFlags`
+   * - `class_name: StringName`
+   * - `default_value: Variant`, default value of the property.
+   * - `update_visibility: bool`, if set to `true`, {@link _get_export_option_visibility} is called for each property when this property is changed.
+   * - `required: bool`, if set to `true`, this property warnings are critical, and should be resolved to make export possible. This value is a hint for the {@link _has_valid_export_configuration} implementation, and not used by the engine directly.
+   * See also {@link Object._get_property_list}.
+   */
+  _get_export_options(): Array<Dictionary>;
+  /**
+   * Returns the platform logo displayed in the export dialog. The logo should be 32×32 pixels, adjusted for the current editor scale (see {@link EditorInterface.get_editor_scale}).
+   */
+  _get_logo(): Texture2D | null;
+  /** Returns export platform name. */
+  _get_name(): string;
+  /**
+   * Returns the item icon for the specified `device` in the one-click deploy menu. The icon should be 16×16 pixels, adjusted for the current editor scale (see {@link EditorInterface.get_editor_scale}).
+   */
+  _get_option_icon(device: int): Texture2D | null;
+  /** Returns one-click deploy menu item label for the specified `device`. */
+  _get_option_label(device: int): string;
+  /** Returns one-click deploy menu item tooltip for the specified `device`. */
+  _get_option_tooltip(device: int): string;
+  /** Returns the number of devices (or other options) available in the one-click deploy menu. */
+  _get_options_count(): int;
+  /** Returns tooltip of the one-click deploy menu button. */
+  _get_options_tooltip(): string;
+  /** Returns target OS name. */
+  _get_os_name(): string;
+  /** Returns array of platform specific features. */
+  _get_platform_features(): PackedStringArray;
+  /** Returns array of platform specific features for the specified `preset`. */
+  _get_preset_features(preset: EditorExportPreset): PackedStringArray;
+  /**
+   * Returns the icon of the one-click deploy menu button. The icon should be 16×16 pixels, adjusted for the current editor scale (see {@link EditorInterface.get_editor_scale}).
+   */
+  _get_run_icon(): Texture2D | null;
+  /** Returns `true` if export configuration is valid. */
+  _has_valid_export_configuration(preset: EditorExportPreset, debug: boolean): boolean;
+  /** Returns `true` if project configuration is valid. */
+  _has_valid_project_configuration(preset: EditorExportPreset): boolean;
+  /** Initializes the plugin. Called by the editor when platform is registered. */
+  _initialize(): void;
+  /**
+   * Returns `true` if specified file is a valid executable (native executable or script) for the target platform.
+   */
+  _is_executable(path: string | NodePath): boolean;
+  /** Returns `true` if one-click deploy options are changed and editor interface should be updated. */
+  _poll_export(): boolean;
+  /**
+   * This method is called when `device` one-click deploy menu option is selected.
+   * Implementation should export project to a temporary location, upload and run it on the specific `device`, or perform another action associated with the menu item.
+   */
+  _run(preset: EditorExportPreset, device: int, debug_flags: int): int;
+  /** Returns `true` if export options list is changed and presets should be updated. */
+  _should_update_export_options(): boolean;
+  /**
+   * Returns current configuration error message text. This method should be called only from the {@link _can_export}, {@link _has_valid_export_configuration}, or {@link _has_valid_project_configuration} implementations.
+   */
+  get_config_error(): string;
+  /**
+   * Returns `true` is export templates are missing from the current configuration. This method should be called only from the {@link _can_export}, {@link _has_valid_export_configuration}, or {@link _has_valid_project_configuration} implementations.
+   */
+  get_config_missing_templates(): boolean;
+  /**
+   * Sets current configuration error message text. This method should be called only from the {@link _can_export}, {@link _has_valid_export_configuration}, or {@link _has_valid_project_configuration} implementations.
+   */
+  set_config_error(error_text: string | NodePath): void;
+  /**
+   * Set to `true` is export templates are missing from the current configuration. This method should be called only from the {@link _can_export}, {@link _has_valid_export_configuration}, or {@link _has_valid_project_configuration} implementations.
+   */
+  set_config_missing_templates(missing_templates: boolean): void;
+}

package/typings/classes/EditorExportPlatformPC.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for the desktop platform exporter (Windows and Linux/BSD). */
+declare class EditorExportPlatformPC extends EditorExportPlatform {
+}