typescript-to-gdscript 0.1.0

package/typings/classes/GraphEdit.d.ts

@@ -0,0 +1,306 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An editor for graph-like structures, using {@link GraphNode}s. */
+declare class GraphEdit extends Control {
+  /**
+   * <member name="connection_lines_antialiased" type="bool" setter="set_connection_lines_antialiased" getter="is_connection_lines_antialiased" default="true">
+   * If `true`, the lines between nodes will use antialiasing.
+   */
+  clip_contents: boolean;
+  /** The curvature of the lines between the nodes. 0 results in straight lines. */
+  connection_lines_curvature: float;
+  /** The thickness of the lines between the nodes. */
+  connection_lines_thickness: float;
+  /**
+   * The connections between {@link GraphNode}s.
+   * A connection is represented as a {@link Dictionary} in the form of:
+   * Connections with `keep_alive` set to `false` may be deleted automatically if invalid during a redraw.
+   */
+  connections: Array<Dictionary>;
+  /**
+   * <member name="grid_pattern" type="int" setter="set_grid_pattern" getter="get_grid_pattern" enum="GraphEdit.GridPattern" default="0">
+   * The pattern used for drawing the grid.
+   */
+  focus_mode: int;
+  /** If `true`, the minimap is visible. */
+  minimap_enabled: boolean;
+  /** The opacity of the minimap rectangle. */
+  minimap_opacity: float;
+  /**
+   * The size of the minimap rectangle. The map itself is based on the size of the grid area and is scaled to fit this rectangle.
+   */
+  minimap_size: Vector2;
+  /** Defines the control scheme for panning with mouse wheel. */
+  panning_scheme: int;
+  /**
+   * If `true`, enables disconnection of existing connections in the GraphEdit by dragging the right end.
+   */
+  right_disconnects: boolean;
+  /** The scroll offset. */
+  scroll_offset: Vector2;
+  /** If `true`, the button to automatically arrange graph nodes is visible. */
+  show_arrange_button: boolean;
+  /** If `true`, the grid is visible. */
+  show_grid: boolean;
+  /** If `true`, buttons that allow to configure grid and snapping options are visible. */
+  show_grid_buttons: boolean;
+  /** If `true`, the menu toolbar is visible. */
+  show_menu: boolean;
+  /** If `true`, the button to toggle the minimap is visible. */
+  show_minimap_button: boolean;
+  /** If `true`, buttons that allow to change and reset the zoom level are visible. */
+  show_zoom_buttons: boolean;
+  /**
+   * If `true`, the label with the current zoom level is visible. The zoom level is displayed in percents.
+   */
+  show_zoom_label: boolean;
+  /** The snapping distance in pixels, also determines the grid line distance. */
+  snapping_distance: int;
+  /** If `true`, enables snapping. */
+  snapping_enabled: boolean;
+  /** {@link Dictionary} of human-readable port type names. */
+  type_names: Dictionary;
+  /** The current zoom value. */
+  zoom: float;
+  /** The upper zoom limit. */
+  zoom_max: float;
+  /** The lower zoom limit. */
+  zoom_min: float;
+  /** The step of each zoom level. */
+  zoom_step: float;
+  set_connection_lines_curvature(value: float): void;
+  get_connection_lines_curvature(): float;
+  set_connection_lines_thickness(value: float): void;
+  get_connection_lines_thickness(): float;
+  set_connections(value: Array<Dictionary>): void;
+  get_connection_list(): Array<Dictionary>;
+  set_minimap_enabled(value: boolean): void;
+  is_minimap_enabled(): boolean;
+  set_minimap_opacity(value: float): void;
+  get_minimap_opacity(): float;
+  set_minimap_size(value: Vector2 | Vector2i): void;
+  get_minimap_size(): Vector2;
+  set_panning_scheme(value: int): void;
+  get_panning_scheme(): int;
+  set_right_disconnects(value: boolean): void;
+  is_right_disconnects_enabled(): boolean;
+  set_scroll_offset(value: Vector2 | Vector2i): void;
+  get_scroll_offset(): Vector2;
+  set_show_arrange_button(value: boolean): void;
+  is_showing_arrange_button(): boolean;
+  set_show_grid(value: boolean): void;
+  is_showing_grid(): boolean;
+  set_show_grid_buttons(value: boolean): void;
+  is_showing_grid_buttons(): boolean;
+  set_show_menu(value: boolean): void;
+  is_showing_menu(): boolean;
+  set_show_minimap_button(value: boolean): void;
+  is_showing_minimap_button(): boolean;
+  set_show_zoom_buttons(value: boolean): void;
+  is_showing_zoom_buttons(): boolean;
+  set_show_zoom_label(value: boolean): void;
+  is_showing_zoom_label(): boolean;
+  set_snapping_distance(value: int): void;
+  get_snapping_distance(): int;
+  set_snapping_enabled(value: boolean): void;
+  is_snapping_enabled(): boolean;
+  set_type_names(value: Dictionary): void;
+  get_type_names(): Dictionary;
+  set_zoom(value: float): void;
+  get_zoom(): float;
+  set_zoom_max(value: float): void;
+  get_zoom_max(): float;
+  set_zoom_min(value: float): void;
+  get_zoom_min(): float;
+  set_zoom_step(value: float): void;
+  get_zoom_step(): float;
+
+  /** Virtual method which can be overridden to customize how connections are drawn. */
+  _get_connection_line(from_position: Vector2 | Vector2i, to_position: Vector2 | Vector2i): PackedVector2Array;
+  /**
+   * Returns whether the `mouse_position` is in the input hot zone.
+   * By default, a hot zone is a {@link Rect2} positioned such that its center is at `in_node`.{@link GraphNode.get_input_port_position}(`in_port`) (For output's case, call {@link GraphNode.get_output_port_position} instead). The hot zone's width is twice the Theme Property `port_grab_distance_horizontal`, and its height is twice the `port_grab_distance_vertical`.
+   * Below is a sample code to help get started:
+   */
+  _is_in_input_hotzone(in_node: GodotObject, in_port: int, mouse_position: Vector2 | Vector2i): boolean;
+  /**
+   * Returns whether the `mouse_position` is in the output hot zone. For more information on hot zones, see {@link _is_in_input_hotzone}.
+   * Below is a sample code to help get started:
+   */
+  _is_in_output_hotzone(in_node: GodotObject, in_port: int, mouse_position: Vector2 | Vector2i): boolean;
+  /**
+   * This virtual method can be used to insert additional error detection while the user is dragging a connection over a valid port.
+   * Return `true` if the connection is indeed valid or return `false` if the connection is impossible. If the connection is impossible, no snapping to the port and thus no connection request to that port will happen.
+   * In this example a connection to same node is suppressed:
+   */
+  _is_node_hover_valid(from_node: string, from_port: int, to_node: string, to_port: int): boolean;
+  /**
+   * Allows the connection between two different port types. The port type is defined individually for the left and the right port of each slot with the {@link GraphNode.set_slot} method.
+   * See also {@link is_valid_connection_type} and {@link remove_valid_connection_type}.
+   */
+  add_valid_connection_type(from_type: int, to_type: int): void;
+  /**
+   * Allows to disconnect nodes when dragging from the left port of the {@link GraphNode}'s slot if it has the specified type. See also {@link remove_valid_left_disconnect_type}.
+   */
+  add_valid_left_disconnect_type(type_: int): void;
+  /**
+   * Allows to disconnect nodes when dragging from the right port of the {@link GraphNode}'s slot if it has the specified type. See also {@link remove_valid_right_disconnect_type}.
+   */
+  add_valid_right_disconnect_type(type_: int): void;
+  /**
+   * Rearranges selected nodes in a layout with minimum crossings between connections and uniform horizontal and vertical gap between nodes.
+   */
+  arrange_nodes(): void;
+  /** Attaches the `element` {@link GraphElement} to the `frame` {@link GraphFrame}. */
+  attach_graph_element_to_frame(element: string, frame: string): void;
+  /** Removes all connections between nodes. */
+  clear_connections(): void;
+  /**
+   * Create a connection between the `from_port` of the `from_node` {@link GraphNode} and the `to_port` of the `to_node` {@link GraphNode}. If the connection already exists, no connection is created.
+   * Connections with `keep_alive` set to `false` may be deleted automatically if invalid during a redraw.
+   */
+  connect_node(from_node: string, from_port: int, to_node: string, to_port: int, keep_alive?: boolean): int;
+  /**
+   * Detaches the `element` {@link GraphElement} from the {@link GraphFrame} it is currently attached to.
+   */
+  detach_graph_element_from_frame(element: string): void;
+  /**
+   * Removes the connection between the `from_port` of the `from_node` {@link GraphNode} and the `to_port` of the `to_node` {@link GraphNode}. If the connection does not exist, no connection is removed.
+   */
+  disconnect_node(from_node: string, from_port: int, to_node: string, to_port: int): void;
+  /**
+   * Ends the creation of the current connection. In other words, if you are dragging a connection you can use this method to abort the process and remove the line that followed your cursor.
+   * This is best used together with {@link connection_drag_started} and {@link connection_drag_ended} to add custom behavior like node addition through shortcuts.
+   * **Note:** This method suppresses any other connection request signals apart from {@link connection_drag_ended}.
+   */
+  force_connection_drag_end(): void;
+  /** Returns an array of node names that are attached to the {@link GraphFrame} with the given name. */
+  get_attached_nodes_of_frame(frame: string): Array<string>;
+  /**
+   * Returns the closest connection to the given point in screen space. If no connection is found within `max_distance` pixels, an empty {@link Dictionary} is returned.
+   * A connection is represented as a {@link Dictionary} in the form of:
+   * For example, getting a connection at a given mouse position can be achieved like this:
+   */
+  get_closest_connection_at_point(point: Vector2 | Vector2i, max_distance?: float): Dictionary;
+  /** Returns the number of connections from `from_port` of `from_node`. */
+  get_connection_count(from_node: string, from_port: int): int;
+  /** Returns the points which would make up a connection between `from_node` and `to_node`. */
+  get_connection_line(from_node: Vector2 | Vector2i, to_node: Vector2 | Vector2i): PackedVector2Array;
+  /**
+   * Returns an {@link Array} containing a list of all connections for `node`.
+   * A connection is represented as a {@link Dictionary} in the form of:
+   * **Example:** Get all connections on a specific port:
+   */
+  get_connection_list_from_node(node: string): Array<Dictionary>;
+  /**
+   * Returns an {@link Array} containing the list of connections that intersect with the given {@link Rect2}.
+   * A connection is represented as a {@link Dictionary} in the form of:
+   */
+  get_connections_intersecting_with_rect(rect: Rect2 | Rect2i): Array<Dictionary>;
+  /** Returns the {@link GraphFrame} that contains the {@link GraphElement} with the given name. */
+  get_element_frame(element: string): GraphFrame | null;
+  /**
+   * Gets the {@link HBoxContainer} that contains the zooming and grid snap controls in the top left of the graph. You can use this method to reposition the toolbar or to add your own custom controls to it.
+   * **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_menu_hbox(): HBoxContainer;
+  /**
+   * Returns `true` if the `from_port` of the `from_node` {@link GraphNode} is connected to the `to_port` of the `to_node` {@link GraphNode}.
+   */
+  is_node_connected(from_node: string, from_port: int, to_node: string, to_port: int): boolean;
+  /**
+   * Returns whether it's possible to make a connection between two different port types. The port type is defined individually for the left and the right port of each slot with the {@link GraphNode.set_slot} method.
+   * See also {@link add_valid_connection_type} and {@link remove_valid_connection_type}.
+   */
+  is_valid_connection_type(from_type: int, to_type: int): boolean;
+  /**
+   * Disallows the connection between two different port types previously allowed by {@link add_valid_connection_type}. The port type is defined individually for the left and the right port of each slot with the {@link GraphNode.set_slot} method.
+   * See also {@link is_valid_connection_type}.
+   */
+  remove_valid_connection_type(from_type: int, to_type: int): void;
+  /**
+   * Disallows to disconnect nodes when dragging from the left port of the {@link GraphNode}'s slot if it has the specified type. Use this to disable a disconnection previously allowed with {@link add_valid_left_disconnect_type}.
+   */
+  remove_valid_left_disconnect_type(type_: int): void;
+  /**
+   * Disallows to disconnect nodes when dragging from the right port of the {@link GraphNode}'s slot if it has the specified type. Use this to disable a disconnection previously allowed with {@link add_valid_right_disconnect_type}.
+   */
+  remove_valid_right_disconnect_type(type_: int): void;
+  /**
+   * Sets the coloration of the connection between `from_node`'s `from_port` and `to_node`'s `to_port` with the color provided in the  theme property. The color is linearly interpolated between the connection color and the activity color using `amount` as weight.
+   */
+  set_connection_activity(from_node: string, from_port: int, to_node: string, to_port: int, amount: float): void;
+  /** Sets the specified `node` as the one selected. */
+  set_selected(node: Node): void;
+
+  /** Emitted at the beginning of a {@link GraphElement}'s movement. */
+  begin_node_move: Signal<[]>;
+  /** Emitted at the end of a connection drag. */
+  connection_drag_ended: Signal<[]>;
+  /** Emitted at the beginning of a connection drag. */
+  connection_drag_started: Signal<[string, int, boolean]>;
+  /** Emitted when user drags a connection from an input port into the empty space of the graph. */
+  connection_from_empty: Signal<[string, int, Vector2]>;
+  /**
+   * Emitted to the GraphEdit when the connection between the `from_port` of the `from_node` {@link GraphNode} and the `to_port` of the `to_node` {@link GraphNode} is attempted to be created.
+   */
+  connection_request: Signal<[string, int, string, int]>;
+  /** Emitted when user drags a connection from an output port into the empty space of the graph. */
+  connection_to_empty: Signal<[string, int, Vector2]>;
+  /**
+   * Emitted when this {@link GraphEdit} captures a `ui_copy` action (`Ctrl + C` by default). In general, this signal indicates that the selected {@link GraphElement}s should be copied.
+   */
+  copy_nodes_request: Signal<[]>;
+  /**
+   * Emitted when this {@link GraphEdit} captures a `ui_cut` action (`Ctrl + X` by default). In general, this signal indicates that the selected {@link GraphElement}s should be cut.
+   */
+  cut_nodes_request: Signal<[]>;
+  /**
+   * Emitted when this {@link GraphEdit} captures a `ui_graph_delete` action (`Delete` by default).
+   * `nodes` is an array of node names that should be removed. These usually include all selected nodes.
+   */
+  delete_nodes_request: Signal<[Array<string>]>;
+  /**
+   * Emitted to the GraphEdit when the connection between `from_port` of `from_node` {@link GraphNode} and `to_port` of `to_node` {@link GraphNode} is attempted to be removed.
+   */
+  disconnection_request: Signal<[string, int, string, int]>;
+  /**
+   * Emitted when this {@link GraphEdit} captures a `ui_graph_duplicate` action (`Ctrl + D` by default). In general, this signal indicates that the selected {@link GraphElement}s should be duplicated.
+   */
+  duplicate_nodes_request: Signal<[]>;
+  /** Emitted at the end of a {@link GraphElement}'s movement. */
+  end_node_move: Signal<[]>;
+  /** Emitted when the {@link GraphFrame} `frame` is resized to `new_rect`. */
+  frame_rect_changed: Signal<[GraphFrame, Rect2]>;
+  /**
+   * Emitted when one or more {@link GraphElement}s are dropped onto the {@link GraphFrame} named `frame`, when they were not previously attached to any other one.
+   * `elements` is an array of {@link GraphElement}s to be attached.
+   */
+  graph_elements_linked_to_frame_request: Signal<[Array<unknown>, string]>;
+  /** Emitted when the given {@link GraphElement} node is deselected. */
+  node_deselected: Signal<[Node]>;
+  /** Emitted when the given {@link GraphElement} node is selected. */
+  node_selected: Signal<[Node]>;
+  /**
+   * Emitted when this {@link GraphEdit} captures a `ui_paste` action (`Ctrl + V` by default). In general, this signal indicates that previously copied {@link GraphElement}s should be pasted.
+   */
+  paste_nodes_request: Signal<[]>;
+  /**
+   * Emitted when a popup is requested. Happens on right-clicking in the GraphEdit. `at_position` is the position of the mouse pointer when the signal is sent.
+   */
+  popup_request: Signal<[Vector2]>;
+  /** Emitted when the scroll offset is changed by the user. It will not be emitted when changed in code. */
+  scroll_offset_changed: Signal<[Vector2]>;
+
+  // enum PanningScheme
+  /** `Mouse Wheel` will zoom, `Ctrl + Mouse Wheel` will move the view. */
+  static readonly SCROLL_ZOOMS: int;
+  /** `Mouse Wheel` will move the view, `Ctrl + Mouse Wheel` will zoom. */
+  static readonly SCROLL_PANS: int;
+  // enum GridPattern
+  /** Draw the grid using solid lines. */
+  static readonly GRID_PATTERN_LINES: int;
+  /** Draw the grid using dots. */
+  static readonly GRID_PATTERN_DOTS: int;
+}

package/typings/classes/GraphElement.d.ts

@@ -0,0 +1,56 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container that represents a basic element that can be placed inside a {@link GraphEdit} control. */
+declare class GraphElement extends Container {
+  /** If `true`, the user can drag the GraphElement. */
+  draggable: boolean;
+  /** The offset of the GraphElement, relative to the scroll offset of the {@link GraphEdit}. */
+  position_offset: Vector2;
+  /**
+   * If `true`, the user can resize the GraphElement.
+   * **Note:** Dragging the handle will only emit the {@link resize_request} and {@link resize_end} signals, the GraphElement needs to be resized manually.
+   */
+  resizable: boolean;
+  /**
+   * If `true`, {@link PopupMenu}s that are descendants of the GraphElement are scaled with the {@link GraphEdit} zoom.
+   */
+  scaling_menus: boolean;
+  /** If `true`, the user can select the GraphElement. */
+  selectable: boolean;
+  /** If `true`, the GraphElement is selected. */
+  selected: boolean;
+  set_draggable(value: boolean): void;
+  is_draggable(): boolean;
+  set_position_offset(value: Vector2 | Vector2i): void;
+  get_position_offset(): Vector2;
+  set_resizable(value: boolean): void;
+  is_resizable(): boolean;
+  set_scaling_menus(value: boolean): void;
+  is_scaling_menus(): boolean;
+  set_selectable(value: boolean): void;
+  is_selectable(): boolean;
+  set_selected(value: boolean): void;
+  is_selected(): boolean;
+
+  /** Emitted when removing the GraphElement is requested. */
+  delete_request: Signal<[]>;
+  /** Emitted when the GraphElement is dragged. */
+  dragged: Signal<[Vector2, Vector2]>;
+  /** Emitted when the GraphElement is deselected. */
+  node_deselected: Signal<[]>;
+  /** Emitted when the GraphElement is selected. */
+  node_selected: Signal<[]>;
+  /** Emitted when the GraphElement is moved. */
+  position_offset_changed: Signal<[]>;
+  /**
+   * Emitted when displaying the GraphElement over other ones is requested. Happens on focusing (clicking into) the GraphElement.
+   */
+  raise_request: Signal<[]>;
+  /** Emitted when releasing the mouse button after dragging the resizer handle (see {@link resizable}). */
+  resize_end: Signal<[Vector2]>;
+  /**
+   * Emitted when resizing the GraphElement is requested. Happens on dragging the resizer handle (see {@link resizable}).
+   */
+  resize_request: Signal<[Vector2]>;
+}

package/typings/classes/GraphFrame.d.ts

@@ -0,0 +1,46 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * GraphFrame is a special {@link GraphElement} that can be used to organize other {@link GraphElement}s inside a {@link GraphEdit}.
+ */
+declare class GraphFrame extends GraphElement {
+  /**
+   * If `true`, the frame's rect will be adjusted automatically to enclose all attached {@link GraphElement}s.
+   */
+  autoshrink_enabled: boolean;
+  /**
+   * The margin around the attached nodes that is used to calculate the size of the frame when {@link autoshrink_enabled} is `true`.
+   */
+  autoshrink_margin: int;
+  /** The margin inside the frame that can be used to drag the frame. */
+  drag_margin: int;
+  /**
+   * <member name="tint_color" type="Color" setter="set_tint_color" getter="get_tint_color" default="Color(0.3, 0.3, 0.3, 0.75)">
+   * The color of the frame when {@link tint_color_enabled} is `true`.
+   */
+  mouse_filter: int;
+  /** If `true`, the tint color will be used to tint the frame. */
+  tint_color_enabled: boolean;
+  /** Title of the frame. */
+  title: string;
+  set_autoshrink_enabled(value: boolean): void;
+  is_autoshrink_enabled(): boolean;
+  set_autoshrink_margin(value: int): void;
+  get_autoshrink_margin(): int;
+  set_drag_margin(value: int): void;
+  get_drag_margin(): int;
+  set_tint_color_enabled(value: boolean): void;
+  is_tint_color_enabled(): boolean;
+  set_title(value: string | NodePath): void;
+  get_title(): string;
+
+  /**
+   * Returns the {@link HBoxContainer} used for the title bar, only containing a {@link Label} for displaying the title by default.
+   * This can be used to add custom controls to the title bar such as option or close buttons.
+   */
+  get_titlebar_hbox(): HBoxContainer;
+
+  /** Emitted when {@link autoshrink_enabled} or {@link autoshrink_margin} changes. */
+  autoshrink_changed: Signal<[]>;
+}

package/typings/classes/GraphNode.d.ts

@@ -0,0 +1,132 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container with connection ports, representing a node in a {@link GraphEdit}. */
+declare class GraphNode extends GraphElement {
+  /**
+   * <member name="ignore_invalid_connection_type" type="bool" setter="set_ignore_invalid_connection_type" getter="is_ignoring_valid_connection_type" default="false">
+   * If `true`, you can connect ports with different types, even if the connection was not explicitly allowed in the parent {@link GraphEdit}.
+   */
+  focus_mode: int;
+  /**
+   * <member name="slots_focus_mode" type="int" setter="set_slots_focus_mode" getter="get_slots_focus_mode" enum="Control.FocusMode" default="3">
+   * Determines how connection slots can be focused.
+   * - If set to {@link Control.FOCUS_CLICK}, connections can only be made with the mouse.
+   * - If set to {@link Control.FOCUS_ALL}, slots can also be focused using the {@link ProjectSettings.input/ui_up} and {@link ProjectSettings.input/ui_down} and connected using {@link ProjectSettings.input/ui_left} and {@link ProjectSettings.input/ui_right} input actions.
+   * - If set to {@link Control.FOCUS_ACCESSIBILITY}, slot input actions are only enabled when the screen reader is active.
+   */
+  mouse_filter: int;
+  /** The text displayed in the GraphNode's title bar. */
+  title: string;
+  set_title(value: string | NodePath): void;
+  get_title(): string;
+
+  _draw_port(slot_index: int, position: Vector2i | Vector2, left: boolean, color: Color): void;
+  /** Disables all slots of the GraphNode. This will remove all input/output ports from the GraphNode. */
+  clear_all_slots(): void;
+  /**
+   * Disables the slot with the given `slot_index`. This will remove the corresponding input and output port from the GraphNode.
+   */
+  clear_slot(slot_index: int): void;
+  /** Returns the {@link Color} of the input port with the given `port_idx`. */
+  get_input_port_color(port_idx: int): Color;
+  /** Returns the number of slots with an enabled input port. */
+  get_input_port_count(): int;
+  /** Returns the position of the input port with the given `port_idx`. */
+  get_input_port_position(port_idx: int): Vector2;
+  /** Returns the corresponding slot index of the input port with the given `port_idx`. */
+  get_input_port_slot(port_idx: int): int;
+  /** Returns the type of the input port with the given `port_idx`. */
+  get_input_port_type(port_idx: int): int;
+  /** Returns the {@link Color} of the output port with the given `port_idx`. */
+  get_output_port_color(port_idx: int): Color;
+  /** Returns the number of slots with an enabled output port. */
+  get_output_port_count(): int;
+  /** Returns the position of the output port with the given `port_idx`. */
+  get_output_port_position(port_idx: int): Vector2;
+  /** Returns the corresponding slot index of the output port with the given `port_idx`. */
+  get_output_port_slot(port_idx: int): int;
+  /** Returns the type of the output port with the given `port_idx`. */
+  get_output_port_type(port_idx: int): int;
+  /** Returns the left (input) {@link Color} of the slot with the given `slot_index`. */
+  get_slot_color_left(slot_index: int): Color;
+  /** Returns the right (output) {@link Color} of the slot with the given `slot_index`. */
+  get_slot_color_right(slot_index: int): Color;
+  /** Returns the left (input) custom {@link Texture2D} of the slot with the given `slot_index`. */
+  get_slot_custom_icon_left(slot_index: int): Texture2D | null;
+  /** Returns the right (output) custom {@link Texture2D} of the slot with the given `slot_index`. */
+  get_slot_custom_icon_right(slot_index: int): Texture2D | null;
+  /** Returns the left (input) metadata of the slot with the given `slot_index`. */
+  get_slot_metadata_left(slot_index: int): unknown;
+  /** Returns the right (output) metadata of the slot with the given `slot_index`. */
+  get_slot_metadata_right(slot_index: int): unknown;
+  /** Returns the left (input) type of the slot with the given `slot_index`. */
+  get_slot_type_left(slot_index: int): int;
+  /** Returns the right (output) type of the slot with the given `slot_index`. */
+  get_slot_type_right(slot_index: int): int;
+  /**
+   * Returns the {@link HBoxContainer} used for the title bar, only containing a {@link Label} for displaying the title by default. This can be used to add custom controls to the title bar such as option or close buttons.
+   */
+  get_titlebar_hbox(): HBoxContainer;
+  /** Returns `true` if the background {@link StyleBox} of the slot with the given `slot_index` is drawn. */
+  is_slot_draw_stylebox(slot_index: int): boolean;
+  /** Returns `true` if left (input) side of the slot with the given `slot_index` is enabled. */
+  is_slot_enabled_left(slot_index: int): boolean;
+  /** Returns `true` if right (output) side of the slot with the given `slot_index` is enabled. */
+  is_slot_enabled_right(slot_index: int): boolean;
+  /**
+   * Sets properties of the slot with the given `slot_index`.
+   * If `enable_left_port`/`enable_right_port` is `true`, a port will appear and the slot will be able to be connected from this side.
+   * With `type_left`/`type_right` an arbitrary type can be assigned to each port. Two ports can be connected if they share the same type, or if the connection between their types is allowed in the parent {@link GraphEdit} (see {@link GraphEdit.add_valid_connection_type}). Keep in mind that the {@link GraphEdit} has the final say in accepting the connection. Type compatibility simply allows the {@link GraphEdit.connection_request} signal to be emitted.
+   * Ports can be further customized using `color_left`/`color_right` and `custom_icon_left`/`custom_icon_right`. The color parameter adds a tint to the icon. The custom icon can be used to override the default port dot.
+   * Additionally, `draw_stylebox` can be used to enable or disable drawing of the background stylebox for each slot. See .
+   * Individual properties can also be set using one of the `set_slot_*` methods.
+   * **Note:** This method only sets properties of the slot. To create the slot itself, add a {@link Control}-derived child to the GraphNode.
+   */
+  set_slot(slot_index: int, enable_left_port: boolean, type_left: int, color_left: Color, enable_right_port: boolean, type_right: int, color_right: Color, custom_icon_left?: Texture2D, custom_icon_right?: Texture2D, draw_stylebox?: boolean): void;
+  /** Sets the {@link Color} of the left (input) side of the slot with the given `slot_index` to `color`. */
+  set_slot_color_left(slot_index: int, color: Color): void;
+  /**
+   * Sets the {@link Color} of the right (output) side of the slot with the given `slot_index` to `color`.
+   */
+  set_slot_color_right(slot_index: int, color: Color): void;
+  /**
+   * Sets the custom {@link Texture2D} of the left (input) side of the slot with the given `slot_index` to `custom_icon`.
+   */
+  set_slot_custom_icon_left(slot_index: int, custom_icon: Texture2D): void;
+  /**
+   * Sets the custom {@link Texture2D} of the right (output) side of the slot with the given `slot_index` to `custom_icon`.
+   */
+  set_slot_custom_icon_right(slot_index: int, custom_icon: Texture2D): void;
+  /** Toggles the background {@link StyleBox} of the slot with the given `slot_index`. */
+  set_slot_draw_stylebox(slot_index: int, enable: boolean): void;
+  /**
+   * Toggles the left (input) side of the slot with the given `slot_index`. If `enable` is `true`, a port will appear on the left side and the slot will be able to be connected from this side.
+   */
+  set_slot_enabled_left(slot_index: int, enable: boolean): void;
+  /**
+   * Toggles the right (output) side of the slot with the given `slot_index`. If `enable` is `true`, a port will appear on the right side and the slot will be able to be connected from this side.
+   */
+  set_slot_enabled_right(slot_index: int, enable: boolean): void;
+  /**
+   * Sets the custom metadata for the left (input) side of the slot with the given `slot_index` to `value`.
+   */
+  set_slot_metadata_left(slot_index: int, value: unknown): void;
+  /**
+   * Sets the custom metadata for the right (output) side of the slot with the given `slot_index` to `value`.
+   */
+  set_slot_metadata_right(slot_index: int, value: unknown): void;
+  /**
+   * Sets the left (input) type of the slot with the given `slot_index` to `type`. If the value is negative, all connections will be disallowed to be created via user inputs.
+   */
+  set_slot_type_left(slot_index: int, type_: int): void;
+  /**
+   * Sets the right (output) type of the slot with the given `slot_index` to `type`. If the value is negative, all connections will be disallowed to be created via user inputs.
+   */
+  set_slot_type_right(slot_index: int, type_: int): void;
+
+  /** Emitted when any slot's size might have changed. */
+  slot_sizes_changed: Signal<[]>;
+  /** Emitted when any GraphNode's slot is updated. */
+  slot_updated: Signal<[int]>;
+}

package/typings/classes/GridContainer.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container that arranges its child controls in a grid layout. */
+declare class GridContainer extends Container {
+  /**
+   * The number of columns in the {@link GridContainer}. If modified, {@link GridContainer} reorders its Control-derived children to accommodate the new layout.
+   */
+  columns: int;
+  set_columns(value: int): void;
+  get_columns(): int;
+}

package/typings/classes/GrooveJoint2D.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A physics joint that restricts the movement of two 2D physics bodies to a fixed axis. */
+declare class GrooveJoint2D extends Joint2D {
+  /**
+   * The body B's initial anchor position defined by the joint's origin and a local offset {@link initial_offset} along the joint's Y axis (along the groove).
+   */
+  initial_offset: float;
+  /**
+   * The groove's length. The groove is from the joint's origin towards {@link length} along the joint's local Y axis.
+   */
+  length: float;
+  set_initial_offset(value: float): void;
+  get_initial_offset(): float;
+  set_length(value: float): void;
+  get_length(): float;
+}

package/typings/classes/HBoxContainer.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container that arranges its child controls horizontally. */
+declare class HBoxContainer extends BoxContainer {
+}

package/typings/classes/HFlowContainer.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A container that arranges its child controls horizontally and wraps them around at the borders. */
+declare class HFlowContainer extends FlowContainer {
+}

package/typings/classes/HMACContext.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Used to create an HMAC for a message using a key. */
+declare class HMACContext extends RefCounted {
+  /** Returns the resulting HMAC. If the HMAC failed, an empty {@link PackedByteArray} is returned. */
+  finish(): PackedByteArray;
+  /**
+   * Initializes the HMACContext. This method cannot be called again on the same HMACContext until {@link finish} has been called.
+   */
+  start(hash_type: int, key: PackedByteArray | Array<unknown>): int;
+  /**
+   * Updates the message to be HMACed. This can be called multiple times before {@link finish} is called to append `data` to the message, but cannot be called until {@link start} has been called.
+   */
+  update(data: PackedByteArray | Array<unknown>): int;
+}

package/typings/classes/HScrollBar.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A horizontal scrollbar that goes from left (min) to right (max). */
+declare class HScrollBar extends ScrollBar {
+}

package/typings/classes/HSeparator.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A horizontal line used for separating other controls. */
+declare class HSeparator extends Separator {
+}

package/typings/classes/HSlider.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A horizontal slider that goes from left (min) to right (max). */
+declare class HSlider extends Slider {
+}

package/typings/classes/HSplitContainer.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A container that splits two child controls horizontally and provides a grabber for adjusting the split ratio.
+ */
+declare class HSplitContainer extends SplitContainer {
+}