typescript-to-gdscript 0.1.0

package/typings/classes/ItemList.d.ts

@@ -0,0 +1,277 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A vertical list of selectable items with one or multiple columns. */
+declare class ItemList extends Control {
+  /** If `true`, the currently selected item can be selected again. */
+  allow_reselect: boolean;
+  /** If `true`, right mouse button click can select items. */
+  allow_rmb_select: boolean;
+  /** If `true`, allows navigating the {@link ItemList} with letter keys through incremental search. */
+  allow_search: boolean;
+  /** If `true`, the control will automatically resize the height to fit its content. */
+  auto_height: boolean;
+  /** If `true`, the control will automatically resize the width to fit its content. */
+  auto_width: boolean;
+  /**
+   * <member name="fixed_column_width" type="int" setter="set_fixed_column_width" getter="get_fixed_column_width" default="0">
+   * The width all columns will be adjusted to.
+   * A value of zero disables the adjustment, each item will have a width equal to the width of its content and the columns will have an uneven width.
+   */
+  clip_contents: boolean;
+  /**
+   * The size all icons will be adjusted to.
+   * If either X or Y component is not greater than zero, icon size won't be affected.
+   */
+  fixed_icon_size: Vector2i;
+  /**
+   * <member name="icon_mode" type="int" setter="set_icon_mode" getter="get_icon_mode" enum="ItemList.IconMode" default="1">
+   * The icon position, whether above or to the left of the text. See the {@link IconMode} constants.
+   */
+  focus_mode: int;
+  /** The scale of icon applied after {@link fixed_icon_size} and transposing takes effect. */
+  icon_scale: float;
+  /** The number of items currently in the list. */
+  item_count: int;
+  /**
+   * Maximum columns the list will have.
+   * If greater than zero, the content will be split among the specified columns.
+   * A value of zero means unlimited columns, i.e. all items will be put in the same row.
+   */
+  max_columns: int;
+  /**
+   * Maximum lines of text allowed in each item. Space will be reserved even when there is not enough lines of text to display.
+   * **Note:** This property takes effect only when {@link icon_mode} is {@link ICON_MODE_TOP}. To make the text wrap, {@link fixed_column_width} should be greater than zero.
+   */
+  max_text_lines: int;
+  /**
+   * Whether all columns will have the same width.
+   * If `true`, the width is equal to the largest column width of all columns.
+   */
+  same_column_width: boolean;
+  /**
+   * The way which scroll hints (indicators that show that the content can still be scrolled in a certain direction) will be shown.
+   */
+  scroll_hint_mode: int;
+  /** Allows single or multiple item selection. See the {@link SelectMode} constants. */
+  select_mode: int;
+  /** The clipping behavior when the text exceeds an item's bounding rectangle. */
+  text_overrun_behavior: int;
+  /**
+   * If `true`, the scroll hint texture will be tiled instead of stretched. See {@link scroll_hint_mode}.
+   */
+  tile_scroll_hint: boolean;
+  /**
+   * If `true`, the control will automatically move items into a new row to fit its content. See also {@link HFlowContainer} for this behavior.
+   * If `false`, the control will add a horizontal scrollbar to make all items visible.
+   */
+  wraparound_items: boolean;
+  set_allow_reselect(value: boolean): void;
+  get_allow_reselect(): boolean;
+  set_allow_rmb_select(value: boolean): void;
+  get_allow_rmb_select(): boolean;
+  set_allow_search(value: boolean): void;
+  get_allow_search(): boolean;
+  set_auto_height(value: boolean): void;
+  has_auto_height(): boolean;
+  set_auto_width(value: boolean): void;
+  has_auto_width(): boolean;
+  set_fixed_icon_size(value: Vector2i | Vector2): void;
+  get_fixed_icon_size(): Vector2i;
+  set_icon_scale(value: float): void;
+  get_icon_scale(): float;
+  set_item_count(value: int): void;
+  get_item_count(): int;
+  set_max_columns(value: int): void;
+  get_max_columns(): int;
+  set_max_text_lines(value: int): void;
+  get_max_text_lines(): int;
+  set_same_column_width(value: boolean): void;
+  is_same_column_width(): boolean;
+  set_scroll_hint_mode(value: int): void;
+  get_scroll_hint_mode(): int;
+  set_select_mode(value: int): void;
+  get_select_mode(): int;
+  set_text_overrun_behavior(value: int): void;
+  get_text_overrun_behavior(): int;
+  set_tile_scroll_hint(value: boolean): void;
+  is_scroll_hint_tiled(): boolean;
+  set_wraparound_items(value: boolean): void;
+  has_wraparound_items(): boolean;
+
+  /** Adds an item to the item list with no text, only an icon. Returns the index of an added item. */
+  add_icon_item(icon: Texture2D, selectable?: boolean): int;
+  /**
+   * Adds an item to the item list with specified text. Returns the index of an added item.
+   * Specify an `icon`, or use `null` as the `icon` for a list item with no icon.
+   * If `selectable` is `true`, the list item will be selectable.
+   */
+  add_item(text: string | NodePath, icon?: Texture2D, selectable?: boolean): int;
+  /**
+   * Ensures the currently selected item (the first selected item if multiple selection is enabled) is visible, adjusting the scroll position as necessary to place the item at the center of the list if possible. See also {@link ensure_current_is_visible}.
+   * Fails and prints an error if both arguments are `false`.
+   */
+  center_on_current(center_verically?: boolean, center_horizontally?: boolean): void;
+  /** Removes all items from the list. */
+  clear(): void;
+  /** Ensures the item associated with the specified index is not selected. */
+  deselect(idx: int): void;
+  /** Ensures there are no items selected. */
+  deselect_all(): void;
+  /**
+   * Ensures the currently selected item (the first selected item if multiple selection is enabled) is visible, adjusting the scroll position as necessary. See also {@link center_on_current}.
+   */
+  ensure_current_is_visible(): void;
+  /**
+   * Forces an update to the list size based on its items. This happens automatically whenever size of the items, or other relevant settings like {@link auto_height}, change. The method can be used to trigger the update ahead of next drawing pass.
+   */
+  force_update_list_size(): void;
+  /**
+   * Returns the horizontal scrollbar.
+   * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+   */
+  get_h_scroll_bar(): HScrollBar;
+  /**
+   * Returns the item index at the given `position`.
+   * When there is no item at that point, -1 will be returned if `exact` is `true`, and the closest item index will be returned otherwise.
+   * **Note:** The returned value is unreliable if called right after modifying the {@link ItemList}, before it redraws in the next frame.
+   */
+  get_item_at_position(position: Vector2 | Vector2i, exact?: boolean): int;
+  /** Returns item's auto translate mode. */
+  get_item_auto_translate_mode(idx: int): int;
+  /** Returns the custom background color of the item specified by `idx` index. */
+  get_item_custom_bg_color(idx: int): Color;
+  /** Returns the custom foreground color of the item specified by `idx` index. */
+  get_item_custom_fg_color(idx: int): Color;
+  /** Returns the icon associated with the specified index. */
+  get_item_icon(idx: int): Texture2D | null;
+  /** Returns a {@link Color} modulating item's icon at the specified index. */
+  get_item_icon_modulate(idx: int): Color;
+  /** Returns the region of item's icon used. The whole icon will be used if the region has no area. */
+  get_item_icon_region(idx: int): Rect2;
+  /** Returns item's text language code. */
+  get_item_language(idx: int): string;
+  /** Returns the metadata value of the specified index. */
+  get_item_metadata(idx: int): unknown;
+  /**
+   * Returns the position and size of the item with the specified index, in the coordinate system of the {@link ItemList} node. If `expand` is `true` the last column expands to fill the rest of the row.
+   * **Note:** The returned value is unreliable if called right after modifying the {@link ItemList}, before it redraws in the next frame.
+   */
+  get_item_rect(idx: int, expand?: boolean): Rect2;
+  /** Returns the text associated with the specified index. */
+  get_item_text(idx: int): string;
+  /** Returns item's text base writing direction. */
+  get_item_text_direction(idx: int): int;
+  /** Returns the tooltip hint associated with the specified index. */
+  get_item_tooltip(idx: int): string;
+  /** Returns an array with the indexes of the selected items. */
+  get_selected_items(): PackedInt32Array;
+  /**
+   * Returns the vertical scrollbar.
+   * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+   */
+  get_v_scroll_bar(): VScrollBar;
+  /** Returns `true` if one or more items are selected. */
+  is_anything_selected(): boolean;
+  /** Returns `true` if the item at the specified index is disabled. */
+  is_item_disabled(idx: int): boolean;
+  /** Returns `true` if the item icon will be drawn transposed, i.e. the X and Y axes are swapped. */
+  is_item_icon_transposed(idx: int): boolean;
+  /** Returns `true` if the item at the specified index is selectable. */
+  is_item_selectable(idx: int): boolean;
+  /** Returns `true` if the tooltip is enabled for specified item index. */
+  is_item_tooltip_enabled(idx: int): boolean;
+  /** Returns `true` if the item at the specified index is currently selected. */
+  is_selected(idx: int): boolean;
+  /** Moves item from index `from_idx` to `to_idx`. */
+  move_item(from_idx: int, to_idx: int): void;
+  /** Removes the item specified by `idx` index from the list. */
+  remove_item(idx: int): void;
+  /**
+   * Selects the item at the specified index.
+   * **Note:** This method does not trigger the item selection signal.
+   */
+  select(idx: int, single?: boolean): void;
+  /**
+   * Sets the auto translate mode of the item associated with the specified index.
+   * Items use {@link Node.AUTO_TRANSLATE_MODE_INHERIT} by default, which uses the same auto translate mode as the {@link ItemList} itself.
+   */
+  set_item_auto_translate_mode(idx: int, mode: int): void;
+  /** Sets the background color of the item specified by `idx` index to the specified {@link Color}. */
+  set_item_custom_bg_color(idx: int, custom_bg_color: Color): void;
+  /** Sets the foreground color of the item specified by `idx` index to the specified {@link Color}. */
+  set_item_custom_fg_color(idx: int, custom_fg_color: Color): void;
+  /**
+   * Disables (or enables) the item at the specified index.
+   * Disabled items cannot be selected and do not trigger activation signals (when double-clicking or pressing `Enter`).
+   */
+  set_item_disabled(idx: int, disabled: boolean): void;
+  /** Sets (or replaces) the icon's {@link Texture2D} associated with the specified index. */
+  set_item_icon(idx: int, icon: Texture2D): void;
+  /** Sets a modulating {@link Color} of the item associated with the specified index. */
+  set_item_icon_modulate(idx: int, modulate: Color): void;
+  /** Sets the region of item's icon used. The whole icon will be used if the region has no area. */
+  set_item_icon_region(idx: int, rect: Rect2 | Rect2i): void;
+  /** Sets whether the item icon will be drawn transposed. */
+  set_item_icon_transposed(idx: int, transposed: boolean): void;
+  /**
+   * Sets the language code of the text for the item at the given index to `language`. This is used for line-breaking and text shaping algorithms. If `language` is empty, the current locale is used.
+   */
+  set_item_language(idx: int, language: string | NodePath): void;
+  /** Sets a value (of any type) to be stored with the item associated with the specified index. */
+  set_item_metadata(idx: int, metadata: unknown): void;
+  /** Allows or disallows selection of the item associated with the specified index. */
+  set_item_selectable(idx: int, selectable: boolean): void;
+  /** Sets text of the item associated with the specified index. */
+  set_item_text(idx: int, text: string | NodePath): void;
+  /** Sets item's text base writing direction. */
+  set_item_text_direction(idx: int, direction: int): void;
+  /** Sets the tooltip hint for the item associated with the specified index. */
+  set_item_tooltip(idx: int, tooltip: string | NodePath): void;
+  /** Sets whether the tooltip hint is enabled for specified item index. */
+  set_item_tooltip_enabled(idx: int, enable: boolean): void;
+  /** Sorts items in the list by their text. */
+  sort_items_by_text(): void;
+
+  /**
+   * Emitted when any mouse click is issued within the rect of the list but on empty space.
+   * `at_position` is the click position in this control's local coordinate system.
+   */
+  empty_clicked: Signal<[Vector2, int]>;
+  /** Emitted when specified list item is activated via double-clicking or by pressing `Enter`. */
+  item_activated: Signal<[int]>;
+  /**
+   * Emitted when specified list item has been clicked with any mouse button.
+   * `at_position` is the click position in this control's local coordinate system.
+   */
+  item_clicked: Signal<[int, Vector2, int]>;
+  /**
+   * Emitted when specified item has been selected. Only applicable in single selection mode.
+   * {@link allow_reselect} must be enabled to reselect an item.
+   */
+  item_selected: Signal<[int]>;
+  /** Emitted when a multiple selection is altered on a list allowing multiple selection. */
+  multi_selected: Signal<[int, boolean]>;
+
+  // enum IconMode
+  /** Icon is drawn above the text. */
+  static readonly ICON_MODE_TOP: int;
+  /** Icon is drawn to the left of the text. */
+  static readonly ICON_MODE_LEFT: int;
+  // enum SelectMode
+  /** Only allow selecting a single item. */
+  static readonly SELECT_SINGLE: int;
+  /** Allows selecting multiple items by holding `Ctrl` or `Shift`. */
+  static readonly SELECT_MULTI: int;
+  /** Allows selecting multiple items by toggling them on and off. */
+  static readonly SELECT_TOGGLE: int;
+  // enum ScrollHintMode
+  /** Scroll hints will never be shown. */
+  static readonly SCROLL_HINT_MODE_DISABLED: int;
+  /** Scroll hints will be shown at the top and bottom. */
+  static readonly SCROLL_HINT_MODE_BOTH: int;
+  /** Only the top scroll hint will be shown. */
+  static readonly SCROLL_HINT_MODE_TOP: int;
+  /** Only the bottom scroll hint will be shown. */
+  static readonly SCROLL_HINT_MODE_BOTTOM: int;
+}

package/typings/classes/IterateIK3D.d.ts

@@ -0,0 +1,85 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link SkeletonModifier3D} to approach the goal by repeating small rotations. */
+declare class IterateIK3D extends ChainIK3D {
+  /**
+   * The maximum amount each bone can rotate in a single iteration.
+   * **Note:** This limitation is applied during each iteration. For example, if {@link max_iterations} is `4` and {@link angular_delta_limit} is `5` degrees, the maximum rotation possible in a single frame is `20` degrees.
+   */
+  angular_delta_limit: float;
+  /**
+   * If `false`, the result is calculated from the previous frame's {@link IterateIK3D} result as the initial state.
+   * If `true`, the previous frame's {@link IterateIK3D} result is discarded. At this point, the new result is calculated from the bone pose excluding the {@link IterateIK3D} as the initial state. This means the result will be always equal as long as the target position and the previous bone pose are the same. However, if {@link angular_delta_limit} and {@link max_iterations} are set too small, the end bone of the chain will never reach the target.
+   */
+  deterministic: boolean;
+  /** The number of iteration loops used by the IK solver to produce more accurate results. */
+  max_iterations: int;
+  /**
+   * The minimum distance between the end bone and the target. If the distance is below this value, the IK solver stops any further iterations.
+   */
+  min_distance: float;
+  /** The number of settings. */
+  setting_count: int;
+  set_angular_delta_limit(value: float): void;
+  get_angular_delta_limit(): float;
+  set_deterministic(value: boolean): void;
+  is_deterministic(): boolean;
+  set_max_iterations(value: int): void;
+  get_max_iterations(): int;
+  set_min_distance(value: float): void;
+  get_min_distance(): float;
+
+  /** Returns the joint limitation at `joint` in the bone chain's joint list. */
+  get_joint_limitation(index: int, joint: int): JointLimitation3D | null;
+  /** Returns the joint limitation right axis at `joint` in the bone chain's joint list. */
+  get_joint_limitation_right_axis(index: int, joint: int): int;
+  /**
+   * Returns the joint limitation right axis vector at `joint` in the bone chain's joint list.
+   * If {@link get_joint_limitation_right_axis} is {@link SkeletonModifier3D.SECONDARY_DIRECTION_NONE}, this method returns `Vector3(0, 0, 0)`.
+   */
+  get_joint_limitation_right_axis_vector(index: int, joint: int): Vector3;
+  /**
+   * Returns the joint limitation rotation offset at `joint` in the bone chain's joint list.
+   * Rotation is done in the local space which is constructed by the bone direction (in general parent to child) as the +Y axis and {@link get_joint_limitation_right_axis_vector} as the +X axis.
+   * If the +X and +Y axes are not orthogonal, the +X axis is implicitly modified to make it orthogonal.
+   * Also, if the length of {@link get_joint_limitation_right_axis_vector} is zero, the space is created by rotating the bone rest using the shortest arc that rotates the +Y axis of the bone rest to match the bone direction.
+   */
+  get_joint_limitation_rotation_offset(index: int, joint: int): Quaternion;
+  /** Returns the rotation axis at `joint` in the bone chain's joint list. */
+  get_joint_rotation_axis(index: int, joint: int): int;
+  /**
+   * Returns the rotation axis vector for the specified joint in the bone chain. This vector represents the axis around which the joint can rotate. It is determined based on the rotation axis set for the joint.
+   * If {@link get_joint_rotation_axis} is {@link SkeletonModifier3D.ROTATION_AXIS_ALL}, this method returns `Vector3(0, 0, 0)`.
+   */
+  get_joint_rotation_axis_vector(index: int, joint: int): Vector3;
+  /** Returns the target node that the end bone is trying to reach. */
+  get_target_node(index: int): NodePath;
+  /** Sets the joint limitation at `joint` in the bone chain's joint list. */
+  set_joint_limitation(index: int, joint: int, limitation: JointLimitation3D): void;
+  /** Sets the joint limitation right axis at `joint` in the bone chain's joint list. */
+  set_joint_limitation_right_axis(index: int, joint: int, direction: int): void;
+  /** Sets the optional joint limitation right axis vector at `joint` in the bone chain's joint list. */
+  set_joint_limitation_right_axis_vector(index: int, joint: int, vector: Vector3 | Vector3i): void;
+  /**
+   * Sets the joint limitation rotation offset at `joint` in the bone chain's joint list.
+   * Rotation is done in the local space which is constructed by the bone direction (in general parent to child) as the +Y axis and {@link get_joint_limitation_right_axis_vector} as the +X axis.
+   * If the +X and +Y axes are not orthogonal, the +X axis is implicitly modified to make it orthogonal.
+   * Also, if the length of {@link get_joint_limitation_right_axis_vector} is zero, the space is created by rotating the bone rest using the shortest arc that rotates the +Y axis of the bone rest to match the bone direction.
+   */
+  set_joint_limitation_rotation_offset(index: int, joint: int, offset: Quaternion | Basis): void;
+  /**
+   * Sets the rotation axis at `joint` in the bone chain's joint list.
+   * The axes are based on the {@link Skeleton3D.get_bone_rest}'s space, if `axis` is {@link SkeletonModifier3D.ROTATION_AXIS_CUSTOM}, you can specify any axis.
+   * **Note:** The rotation axis and the forward vector shouldn't be colinear to avoid unintended rotation since {@link ChainIK3D} does not factor in twisting forces.
+   */
+  set_joint_rotation_axis(index: int, joint: int, axis: int): void;
+  /**
+   * Sets the rotation axis vector for the specified joint in the bone chain.
+   * This vector is normalized by an internal process and represents the axis around which the bone chain can rotate.
+   * If the vector length is `0`, it is considered synonymous with {@link SkeletonModifier3D.ROTATION_AXIS_ALL}.
+   */
+  set_joint_rotation_axis_vector(index: int, joint: int, axis_vector: Vector3 | Vector3i): void;
+  /** Sets the target node that the end bone is trying to reach. */
+  set_target_node(index: int, target_node: NodePath | string): void;
+}

package/typings/classes/JNISingleton.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Singleton that connects the engine with Android plugins to interface with native Android code. */
+declare class JNISingleton extends GodotObject {
+  /** Returns `true` if the given `method` name exists in the JNISingleton's Java methods. */
+  has_java_method(method: string): boolean;
+}

package/typings/classes/JSON.d.ts

@@ -0,0 +1,53 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Helper class for creating and parsing JSON data. */
+declare class JSON extends Resource {
+  /** Contains the parsed JSON data in {@link Variant} form. */
+  data: unknown;
+  set_data(value: unknown): void;
+  get_data(): unknown;
+
+  /**
+   * Converts a native engine type to a JSON-compliant value.
+   * By default, objects are ignored for security reasons, unless `full_objects` is `true`.
+   * You can convert a native value to a JSON string like this:
+   */
+  static from_native(variant: unknown, full_objects?: boolean): unknown;
+  /**
+   * Returns `0` if the last call to {@link parse} was successful, or the line number where the parse failed.
+   */
+  get_error_line(): int;
+  /**
+   * Returns an empty string if the last call to {@link parse} was successful, or the error message if it failed.
+   */
+  get_error_message(): string;
+  /** Return the text parsed by {@link parse} (requires passing `keep_text` to {@link parse}). */
+  get_parsed_text(): string;
+  /**
+   * Attempts to parse the `json_text` provided.
+   * Returns an {@link Error}. If the parse was successful, it returns {@link OK} and the result can be retrieved using {@link data}. If unsuccessful, use {@link get_error_line} and {@link get_error_message} to identify the source of the failure.
+   * Non-static variant of {@link parse_string}, if you want custom error handling.
+   * The optional `keep_text` argument instructs the parser to keep a copy of the original text. This text can be obtained later by using the {@link get_parsed_text} function and is used when saving the resource (instead of generating new text from {@link data}).
+   */
+  parse(json_text: string | NodePath, keep_text?: boolean): int;
+  /**
+   * Attempts to parse the `json_string` provided and returns the parsed data. Returns `null` if parse failed.
+   */
+  static parse_string(json_string: string | NodePath): unknown;
+  /**
+   * Converts a {@link Variant} var to JSON text and returns the result. Useful for serializing data to store or send over the network.
+   * **Note:** The JSON specification does not define integer or float types, but only a *number* type. Therefore, converting a Variant to JSON text will convert all numerical values to [float] types.
+   * **Note:** If `full_precision` is `true`, when stringifying floats, the unreliable digits are stringified in addition to the reliable digits to guarantee exact decoding.
+   * The `indent` parameter controls if and how something is indented; its contents will be used where there should be an indent in the output. Even spaces like `"   "` will work. `\t` and `\n` can also be used for a tab indent, or to make a newline for each indent respectively.
+   * **Warning:** Non-finite numbers are not supported in JSON. Any occurrences of {@link @GDScript.INF} will be replaced with `1e99999`, and negative {@link @GDScript.INF} will be replaced with `-1e99999`, but they will be interpreted correctly as infinity by most JSON parsers. {@link @GDScript.NAN} will be replaced with `null`, and it will not be interpreted as NaN in JSON parsers. If you expect non-finite numbers, consider passing your data through {@link from_native} first.
+   * **Example output:**
+   */
+  static stringify(data: unknown, indent?: string | NodePath, sort_keys?: boolean, full_precision?: boolean): string;
+  /**
+   * Converts a JSON-compliant value that was created with {@link from_native} back to native engine types.
+   * By default, objects are ignored for security reasons, unless `allow_objects` is `true`.
+   * You can convert a JSON string back to a native value like this:
+   */
+  static to_native(json: unknown, allow_objects?: boolean): unknown;
+}

package/typings/classes/JSONRPC.d.ts

@@ -0,0 +1,59 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A helper to handle dictionaries which look like JSONRPC documents. */
+declare class JSONRPC extends GodotObject {
+  /**
+   * Returns a dictionary in the form of a JSON-RPC notification. Notifications are one-shot messages which do not expect a response.
+   * - `method`: Name of the method being called.
+   * - `params`: An array or dictionary of parameters being passed to the method.
+   */
+  make_notification(method: string | NodePath, params: unknown): Dictionary;
+  /**
+   * Returns a dictionary in the form of a JSON-RPC request. Requests are sent to a server with the expectation of a response. The ID field is used for the server to specify which exact request it is responding to.
+   * - `method`: Name of the method being called.
+   * - `params`: An array or dictionary of parameters being passed to the method.
+   * - `id`: Uniquely identifies this request. The server is expected to send a response with the same ID.
+   */
+  make_request(method: string | NodePath, params: unknown, id: unknown): Dictionary;
+  /**
+   * When a server has received and processed a request, it is expected to send a response. If you did not want a response then you need to have sent a Notification instead.
+   * - `result`: The return value of the function which was called.
+   * - `id`: The ID of the request this response is targeted to.
+   */
+  make_response(result: unknown, id: unknown): Dictionary;
+  /**
+   * Creates a response which indicates a previous reply has failed in some way.
+   * - `code`: The error code corresponding to what kind of error this is. See the {@link ErrorCode} constants.
+   * - `message`: A custom message about this error.
+   * - `id`: The request this error is a response to.
+   */
+  make_response_error(code: int, message: string | NodePath, id?: unknown): Dictionary;
+  /**
+   * Given a Dictionary which takes the form of a JSON-RPC request: unpack the request and run it. Methods are resolved by looking at the field called "method" and looking for an equivalently named function in the JSONRPC object. If one is found that method is called.
+   * To add new supported methods extend the JSONRPC class and call {@link process_action} on your subclass.
+   * `action`: The action to be run, as a Dictionary in the form of a JSON-RPC request or notification.
+   */
+  process_action(action: unknown, recurse?: boolean): unknown;
+  process_string(action: string | NodePath): string;
+  /**
+   * Registers a callback for the given method name.
+   * - `name`: The name that clients can use to access the callback.
+   * - `callback`: The callback which will handle the specified method.
+   */
+  set_method(name: string | NodePath, callback: Callable): void;
+
+  // enum ErrorCode
+  /** The request could not be parsed as it was not valid by JSON standard ({@link JSON.parse} failed). */
+  static readonly PARSE_ERROR: int;
+  /** A method call was requested but the request's format is not valid. */
+  static readonly INVALID_REQUEST: int;
+  /** A method call was requested but no function of that name existed in the JSONRPC subclass. */
+  static readonly METHOD_NOT_FOUND: int;
+  /**
+   * A method call was requested but the given method parameters are not valid. Not used by the built-in JSONRPC.
+   */
+  static readonly INVALID_PARAMS: int;
+  /** An internal error occurred while processing the request. Not used by the built-in JSONRPC. */
+  static readonly INTERNAL_ERROR: int;
+}

package/typings/classes/JacobianIK3D.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Jacobian transpose based inverse kinematics solver. */
+declare class JacobianIK3D extends IterateIK3D {
+}

package/typings/classes/JavaClass.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a class from the Java Native Interface. */
+declare class JavaClass extends RefCounted {
+  /** Returns the Java class name. */
+  get_java_class_name(): string;
+  /**
+   * Returns the object's Java methods and their signatures as an {@link Array} of dictionaries, in the same format as {@link Object.get_method_list}.
+   */
+  get_java_method_list(): Array<Dictionary>;
+  /** Returns a {@link JavaClass} representing the Java parent class of this class. */
+  get_java_parent_class(): JavaClass | null;
+  /** Returns `true` if the given `method` name exists in the object's Java methods. */
+  has_java_method(method: string): boolean;
+}

package/typings/classes/JavaClassWrapper.d.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides access to the Java Native Interface. */
+declare interface JavaClassWrapper extends GodotObject {
+  /**
+   * Returns the Java exception from the last call into a Java class. If there was no exception, it will return `null`.
+   * **Note:** This method only works on Android. On every other platform, this method will always return `null`.
+   */
+  get_exception(): JavaObject | null;
+  /**
+   * Wraps a class defined in Java, and returns it as a {@link JavaClass} {@link Object} type that Godot can interact with.
+   * When wrapping inner (nested) classes, use `$` instead of `.` to separate them. For example, `JavaClassWrapper.wrap("android.view.WindowManager$LayoutParams")` wraps the **WindowManager.LayoutParams** class.
+   * **Note:** To invoke a constructor, call a method with the same name as the class. For example:
+   * **Note:** This method only works on Android. On every other platform, this method does nothing and returns an empty {@link JavaClass}.
+   */
+  wrap(name: string | NodePath): JavaClass | null;
+}
+declare const JavaClassWrapper: JavaClassWrapper;
+

package/typings/classes/JavaObject.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents an object from the Java Native Interface. */
+declare class JavaObject extends RefCounted {
+  /** Returns the {@link JavaClass} that this object is an instance of. */
+  get_java_class(): JavaClass | null;
+  /** Returns `true` if the given `method` name exists in the object's Java methods. */
+  has_java_method(method: string): boolean;
+}

package/typings/classes/JavaScriptBridge.d.ts

@@ -0,0 +1,62 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Singleton that connects the engine with the browser's JavaScript context in Web export. */
+declare interface JavaScriptBridge extends GodotObject {
+  /**
+   * Creates a reference to a {@link Callable} that can be used as a callback by JavaScript. The reference must be kept until the callback happens, or it won't be called at all. See {@link JavaScriptObject} for usage.
+   * **Note:** The callback function must take exactly one {@link Array} argument, which is going to be the JavaScript arguments object (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments) converted to an array.
+   */
+  create_callback(callable: Callable): JavaScriptObject | null;
+  /**
+   * Creates a new JavaScript object using the `new` constructor. The `object` must a valid property of the JavaScript `window`. See {@link JavaScriptObject} for usage.
+   */
+  create_object(object: string | NodePath, ...args: any[]): unknown;
+  /**
+   * Prompts the user to download a file containing the specified `buffer`. The file will have the given `name` and `mime` type.
+   * **Note:** The browser may override the MIME type (https://en.wikipedia.org/wiki/Media_type) provided based on the file `name`'s extension.
+   * **Note:** Browsers might block the download if {@link download_buffer} is not being called from a user interaction (e.g. button click).
+   * **Note:** Browsers might ask the user for permission or block the download if multiple download requests are made in a quick succession.
+   */
+  download_buffer(buffer: PackedByteArray | Array<unknown>, name: string | NodePath, mime?: string | NodePath): void;
+  /**
+   * Execute the string `code` as JavaScript code within the browser window. This is a call to the actual global JavaScript function [code skip-lint]eval()[/code].
+   * If `use_global_execution_context` is `true`, the code will be evaluated in the global execution context. Otherwise, it is evaluated in the execution context of a function within the engine's runtime environment.
+   */
+  eval(code: string | NodePath, use_global_execution_context?: boolean): unknown;
+  /**
+   * Force synchronization of the persistent file system (when enabled).
+   * **Note:** This is only useful for modules or extensions that can't use {@link FileAccess} to write files.
+   */
+  force_fs_sync(): void;
+  /**
+   * Returns an interface to a JavaScript object that can be used by scripts. The `interface` must be a valid property of the JavaScript `window`. The callback must accept a single {@link Array} argument, which will contain the JavaScript `arguments`. See {@link JavaScriptObject} for usage.
+   */
+  get_interface(interface_: string | NodePath): JavaScriptObject | null;
+  /**
+   * Returns `true` if the given `javascript_object` is of type `ArrayBuffer` (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer), `DataView` (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView), or one of the many typed array objects (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray).
+   */
+  is_js_buffer(javascript_object: JavaScriptObject): boolean;
+  /**
+   * Returns a copy of `javascript_buffer`'s contents as a {@link PackedByteArray}. See also {@link is_js_buffer}.
+   */
+  js_buffer_to_packed_byte_array(javascript_buffer: JavaScriptObject): PackedByteArray;
+  /**
+   * Returns `true` if a new version of the progressive web app is waiting to be activated.
+   * **Note:** Only relevant when exported as a Progressive Web App.
+   */
+  pwa_needs_update(): boolean;
+  /**
+   * Performs the live update of the progressive web app. Forcing the new version to be installed and the page to be reloaded.
+   * **Note:** Your application will be **reloaded in all browser tabs**.
+   * **Note:** Only relevant when exported as a Progressive Web App and {@link pwa_needs_update} returns `true`.
+   */
+  pwa_update(): int;
+
+  /**
+   * Emitted when an update for this progressive web app has been detected but is waiting to be activated because a previous version is active. See {@link pwa_update} to force the update to take place immediately.
+   */
+  pwa_update_available: Signal<[]>;
+}
+declare const JavaScriptBridge: JavaScriptBridge;
+

package/typings/classes/JavaScriptObject.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A wrapper class for web native JavaScript objects. */
+declare class JavaScriptObject extends RefCounted {
+}

package/typings/classes/Joint2D.d.ts

@@ -0,0 +1,28 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for all 2D physics joints. */
+declare class Joint2D extends Node2D {
+  /**
+   * When {@link node_a} and {@link node_b} move in different directions the {@link bias} controls how fast the joint pulls them back to their original position. The lower the {@link bias} the more the two bodies can pull on the joint.
+   * When set to `0`, the default value from {@link ProjectSettings.physics/2d/solver/default_constraint_bias} is used.
+   */
+  bias: float;
+  /** If `true`, the two bodies bound together do not collide with each other. */
+  disable_collision: boolean;
+  /** Path to the first body (A) attached to the joint. The node must inherit {@link PhysicsBody2D}. */
+  node_a: NodePath;
+  /** Path to the second body (B) attached to the joint. The node must inherit {@link PhysicsBody2D}. */
+  node_b: NodePath;
+  set_bias(value: float): void;
+  get_bias(): float;
+  set_exclude_nodes_from_collision(value: boolean): void;
+  get_exclude_nodes_from_collision(): boolean;
+  set_node_a(value: NodePath | string): void;
+  get_node_a(): NodePath;
+  set_node_b(value: NodePath | string): void;
+  get_node_b(): NodePath;
+
+  /** Returns the joint's internal {@link RID} from the {@link PhysicsServer2D}. */
+  get_rid(): RID;
+}