typescript-to-gdscript 0.1.0

package/typings/classes/AABB.d.ts

@@ -0,0 +1,177 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D axis-aligned bounding box. */
+declare interface AABB {
+  /**
+   * The ending point. This is usually the corner on the top-right and back of the bounding box, and is equivalent to `position + size`. Setting this point affects the {@link size}.
+   */
+  end: Vector3;
+  /** The origin point. This is usually the corner on the bottom-left and forward of the bounding box. */
+  position: Vector3;
+  /**
+   * The bounding box's width, height, and depth starting from {@link position}. Setting this value also affects the {@link end} point.
+   * **Note:** It's recommended setting the width, height, and depth to non-negative values. This is because most methods in Godot assume that the {@link position} is the bottom-left-forward corner, and the {@link end} is the top-right-back corner. To get an equivalent bounding box with non-negative size, use {@link abs}.
+   */
+  size: Vector3;
+
+  /**
+   * Returns an {@link AABB} equivalent to this bounding box, with its width, height, and depth modified to be non-negative values.
+   * **Note:** It's recommended to use this method when {@link size} is negative, as most other methods in Godot assume that the {@link size}'s components are greater than `0`.
+   */
+  abs(): AABB;
+  /**
+   * Returns `true` if this bounding box *completely* encloses the `with` box. The edges of both boxes are included.
+   */
+  encloses(with_: AABB): boolean;
+  /**
+   * Returns a copy of this bounding box expanded to align the edges with the given `to_point`, if necessary.
+   */
+  expand(to_point: Vector3 | Vector3i): AABB;
+  /** Returns the center point of the bounding box. This is the same as `position + (size / 2.0)`. */
+  get_center(): Vector3;
+  /**
+   * Returns the position of one of the 8 vertices that compose this bounding box. With an `idx` of `0` this is the same as {@link position}, and an `idx` of `7` is the same as {@link end}.
+   */
+  get_endpoint(idx: int): Vector3;
+  /**
+   * Returns the longest normalized axis of this bounding box's {@link size}, as a {@link Vector3} ({@link Vector3.RIGHT}, {@link Vector3.UP}, or {@link Vector3.BACK}).
+   * See also {@link get_longest_axis_index} and {@link get_longest_axis_size}.
+   */
+  get_longest_axis(): Vector3;
+  /**
+   * Returns the index to the longest axis of this bounding box's {@link size} (see {@link Vector3.AXIS_X}, {@link Vector3.AXIS_Y}, and {@link Vector3.AXIS_Z}).
+   * For an example, see {@link get_longest_axis}.
+   */
+  get_longest_axis_index(): int;
+  /**
+   * Returns the longest dimension of this bounding box's {@link size}.
+   * For an example, see {@link get_longest_axis}.
+   */
+  get_longest_axis_size(): float;
+  /**
+   * Returns the shortest normalized axis of this bounding box's {@link size}, as a {@link Vector3} ({@link Vector3.RIGHT}, {@link Vector3.UP}, or {@link Vector3.BACK}).
+   * See also {@link get_shortest_axis_index} and {@link get_shortest_axis_size}.
+   */
+  get_shortest_axis(): Vector3;
+  /**
+   * Returns the index to the shortest axis of this bounding box's {@link size} (see {@link Vector3.AXIS_X}, {@link Vector3.AXIS_Y}, and {@link Vector3.AXIS_Z}).
+   * For an example, see {@link get_shortest_axis}.
+   */
+  get_shortest_axis_index(): int;
+  /**
+   * Returns the shortest dimension of this bounding box's {@link size}.
+   * For an example, see {@link get_shortest_axis}.
+   */
+  get_shortest_axis_size(): float;
+  /**
+   * Returns the vertex's position of this bounding box that's the farthest in the given direction. This point is commonly known as the support point in collision detection algorithms.
+   */
+  get_support(direction: Vector3 | Vector3i): Vector3;
+  /**
+   * Returns the bounding box's volume. This is equivalent to `size.x * size.y * size.z`. See also {@link has_volume}.
+   */
+  get_volume(): float;
+  /**
+   * Returns a copy of this bounding box extended on all sides by the given amount `by`. A negative amount shrinks the box instead.
+   */
+  grow(by: float): AABB;
+  /**
+   * Returns `true` if the bounding box contains the given `point`. By convention, points exactly on the right, top, and front sides are **not** included.
+   * **Note:** This method is not reliable for {@link AABB} with a *negative* {@link size}. Use {@link abs} first to get a valid bounding box.
+   */
+  has_point(point: Vector3 | Vector3i): boolean;
+  /**
+   * Returns `true` if this bounding box has a surface or a length, that is, at least one component of {@link size} is greater than `0`. Otherwise, returns `false`.
+   */
+  has_surface(): boolean;
+  /**
+   * Returns `true` if this bounding box's width, height, and depth are all positive. See also {@link get_volume}.
+   */
+  has_volume(): boolean;
+  /**
+   * Returns the intersection between this bounding box and `with`. If the boxes do not intersect, returns an empty {@link AABB}. If the boxes intersect at the edge, returns a flat {@link AABB} with no volume (see {@link has_surface} and {@link has_volume}).
+   * **Note:** If you only need to know whether two bounding boxes are intersecting, use {@link intersects}, instead.
+   */
+  intersection(with_: AABB): AABB;
+  /**
+   * Returns `true` if this bounding box overlaps with the box `with`. The edges of both boxes are *always* excluded.
+   */
+  intersects(with_: AABB): boolean;
+  /** Returns `true` if this bounding box is on both sides of the given `plane`. */
+  intersects_plane(plane: Plane): boolean;
+  /**
+   * Returns the first point where this bounding box and the given ray intersect, as a {@link Vector3}. If no intersection occurs, returns `null`.
+   * The ray begin at `from`, faces `dir` and extends towards infinity.
+   */
+  intersects_ray(from_: Vector3 | Vector3i, dir: Vector3 | Vector3i): unknown;
+  /**
+   * Returns the first point where this bounding box and the given segment intersect, as a {@link Vector3}. If no intersection occurs, returns `null`.
+   * The segment begins at `from` and ends at `to`.
+   */
+  intersects_segment(from_: Vector3 | Vector3i, to: Vector3 | Vector3i): unknown;
+  /**
+   * Returns `true` if this bounding box and `aabb` are approximately equal, by calling {@link Vector3.is_equal_approx} on the {@link position} and the {@link size}.
+   */
+  is_equal_approx(aabb: AABB): boolean;
+  /**
+   * Returns `true` if this bounding box's values are finite, by calling {@link Vector3.is_finite} on the {@link position} and the {@link size}.
+   */
+  is_finite(): boolean;
+  /**
+   * Returns an {@link AABB} that encloses both this bounding box and `with` around the edges. See also {@link encloses}.
+   */
+  merge(with_: AABB): AABB;
+
+  // Operator overloads
+  [__ops_ne]: { right: AABB; ret: boolean };
+  [__ops_mul]: { right: Transform3D; ret: AABB };
+  [__ops_eq]: { right: AABB; ret: boolean };
+
+  [__variant_converts]: AABB;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  clear: never;
+  duplicate: never;
+  duplicate_deep: never;
+  erase: never;
+  find_key: never;
+  get: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has: never;
+  has_all: never;
+  hash: never;
+  is_empty: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merged: never;
+  recursive_equal: never;
+  set: never;
+  sort: never;
+  values: never;
+}
+
+declare interface AABBConstructor {
+  readonly prototype: AABB;
+  /** Constructs an {@link AABB} with its {@link position} and {@link size} set to {@link Vector3.ZERO}. */
+  (): AABB;
+  /** Constructs an {@link AABB} as a copy of the given {@link AABB}. */
+  (from_: AABB): AABB;
+  /** Constructs an {@link AABB} by `position` and `size`. */
+  (position: Vector3, size: Vector3): AABB;
+}
+declare const AABB: AABBConstructor;

package/typings/classes/AESContext.d.ts

@@ -0,0 +1,34 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides access to AES encryption/decryption of raw data. */
+declare class AESContext extends RefCounted {
+  /** Close this AES context so it can be started again. See {@link start}. */
+  finish(): void;
+  /**
+   * Get the current IV state for this context (IV gets updated when calling {@link update}). You normally don't need this function.
+   * **Note:** This function only makes sense when the context is started with {@link MODE_CBC_ENCRYPT} or {@link MODE_CBC_DECRYPT}.
+   */
+  get_iv_state(): PackedByteArray;
+  /**
+   * Start the AES context in the given `mode`. A `key` of either 16 or 32 bytes must always be provided, while an `iv` (initialization vector) of exactly 16 bytes, is only needed when `mode` is either {@link MODE_CBC_ENCRYPT} or {@link MODE_CBC_DECRYPT}.
+   */
+  start(mode: int, key: PackedByteArray | Array<unknown>, iv?: PackedByteArray | Array<unknown>): int;
+  /**
+   * Run the desired operation for this AES context. Will return a {@link PackedByteArray} containing the result of encrypting (or decrypting) the given `src`. See {@link start} for mode of operation.
+   * **Note:** The size of `src` must be a multiple of 16. Apply some padding if needed.
+   */
+  update(src: PackedByteArray | Array<unknown>): PackedByteArray;
+
+  // enum Mode
+  /** AES electronic codebook encryption mode. */
+  static readonly MODE_ECB_ENCRYPT: int;
+  /** AES electronic codebook decryption mode. */
+  static readonly MODE_ECB_DECRYPT: int;
+  /** AES cipher block chaining encryption mode. */
+  static readonly MODE_CBC_ENCRYPT: int;
+  /** AES cipher block chaining decryption mode. */
+  static readonly MODE_CBC_DECRYPT: int;
+  /** Maximum value for the mode enum. */
+  static readonly MODE_MAX: int;
+}

package/typings/classes/AStar2D.d.ts

@@ -0,0 +1,108 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * An implementation of A* for finding the shortest path between two vertices on a connected graph in 2D space.
+ */
+declare class AStar2D extends RefCounted {
+  /** If `true` enables the filtering of neighbors via {@link _filter_neighbor}. */
+  neighbor_filter_enabled: boolean;
+  set_neighbor_filter_enabled(value: boolean): void;
+  is_neighbor_filter_enabled(): boolean;
+
+  /**
+   * Called when computing the cost between two connected points.
+   * Note that this function is hidden in the default {@link AStar2D} class.
+   */
+  _compute_cost(from_id: int, to_id: int): float;
+  /**
+   * Called when estimating the cost between a point and the path's ending point.
+   * Note that this function is hidden in the default {@link AStar2D} class.
+   */
+  _estimate_cost(from_id: int, end_id: int): float;
+  /**
+   * Called when neighboring enters processing and if {@link neighbor_filter_enabled} is `true`. If `true` is returned the point will not be processed.
+   * Note that this function is hidden in the default {@link AStar2D} class.
+   */
+  _filter_neighbor(from_id: int, neighbor_id: int): boolean;
+  /**
+   * Adds a new point at the given position with the given identifier. The `id` must be 0 or larger, and the `weight_scale` must be 0.0 or greater.
+   * The `weight_scale` is multiplied by the result of {@link _compute_cost} when determining the overall cost of traveling across a segment from a neighboring point to this point. Thus, all else being equal, the algorithm prefers points with lower `weight_scale`s to form a path.
+   * If there already exists a point for the given `id`, its position and weight scale are updated to the given values.
+   */
+  add_point(id: int, position: Vector2 | Vector2i, weight_scale?: float): void;
+  /**
+   * Returns whether there is a connection/segment between the given points. If `bidirectional` is `false`, returns whether movement from `id` to `to_id` is possible through this segment.
+   */
+  are_points_connected(id: int, to_id: int, bidirectional?: boolean): boolean;
+  /** Clears all the points and segments. */
+  clear(): void;
+  /**
+   * Creates a segment between the given points. If `bidirectional` is `false`, only movement from `id` to `to_id` is allowed, not the reverse direction.
+   */
+  connect_points(id: int, to_id: int, bidirectional?: boolean): void;
+  /**
+   * Deletes the segment between the given points. If `bidirectional` is `false`, only movement from `id` to `to_id` is prevented, and a unidirectional segment possibly remains.
+   */
+  disconnect_points(id: int, to_id: int, bidirectional?: boolean): void;
+  /** Returns the next available point ID with no point associated to it. */
+  get_available_point_id(): int;
+  /**
+   * Returns the ID of the closest point to `to_position`, optionally taking disabled points into account. Returns `-1` if there are no points in the points pool.
+   * **Note:** If several points are the closest to `to_position`, the one with the smallest ID will be returned, ensuring a deterministic result.
+   */
+  get_closest_point(to_position: Vector2 | Vector2i, include_disabled?: boolean): int;
+  /**
+   * Returns the closest position to `to_position` that resides inside a segment between two connected points.
+   * The result is in the segment that goes from `y = 0` to `y = 5`. It's the closest position in the segment to the given point.
+   */
+  get_closest_position_in_segment(to_position: Vector2 | Vector2i): Vector2;
+  /**
+   * Returns an array with the IDs of the points that form the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path.
+   * If `from_id` point is disabled, returns an empty array (even if `from_id == to_id`).
+   * If `from_id` point is not disabled, there is no valid path to the target, and `allow_partial_path` is `true`, returns a path to the point closest to the target that can be reached.
+   * **Note:** When `allow_partial_path` is `true` and `to_id` is disabled the search may take an unusually long time to finish.
+   * If you change the 2nd point's weight to 3, then the result will be `[1, 4, 3]` instead, because now even though the distance is longer, it's "easier" to get through point 4 than through point 2.
+   */
+  get_id_path(from_id: int, to_id: int, allow_partial_path?: boolean): PackedInt64Array;
+  /**
+   * Returns the capacity of the structure backing the points, useful in conjunction with {@link reserve_space}.
+   */
+  get_point_capacity(): int;
+  /** Returns an array with the IDs of the points that form the connection with the given point. */
+  get_point_connections(id: int): PackedInt64Array;
+  /** Returns the number of points currently in the points pool. */
+  get_point_count(): int;
+  /** Returns an array of all point IDs. */
+  get_point_ids(): PackedInt64Array;
+  /**
+   * Returns an array with the points that are in the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path.
+   * If `from_id` point is disabled, returns an empty array (even if `from_id == to_id`).
+   * If `from_id` point is not disabled, there is no valid path to the target, and `allow_partial_path` is `true`, returns a path to the point closest to the target that can be reached.
+   * **Note:** This method is not thread-safe; it can only be used from a single {@link Thread} at a given time. Consider using {@link Mutex} to ensure exclusive access to one thread to avoid race conditions.
+   * Additionally, when `allow_partial_path` is `true` and `to_id` is disabled the search may take an unusually long time to finish.
+   */
+  get_point_path(from_id: int, to_id: int, allow_partial_path?: boolean): PackedVector2Array;
+  /** Returns the position of the point associated with the given `id`. */
+  get_point_position(id: int): Vector2;
+  /** Returns the weight scale of the point associated with the given `id`. */
+  get_point_weight_scale(id: int): float;
+  /** Returns whether a point associated with the given `id` exists. */
+  has_point(id: int): boolean;
+  /** Returns whether a point is disabled or not for pathfinding. By default, all points are enabled. */
+  is_point_disabled(id: int): boolean;
+  /** Removes the point associated with the given `id` from the points pool. */
+  remove_point(id: int): void;
+  /**
+   * Reserves space internally for `num_nodes` points. Useful if you're adding a known large number of points at once, such as points on a grid.
+   */
+  reserve_space(num_nodes: int): void;
+  /** Disables or enables the specified point for pathfinding. Useful for making a temporary obstacle. */
+  set_point_disabled(id: int, disabled?: boolean): void;
+  /** Sets the `position` for the point with the given `id`. */
+  set_point_position(id: int, position: Vector2 | Vector2i): void;
+  /**
+   * Sets the `weight_scale` for the point with the given `id`. The `weight_scale` is multiplied by the result of {@link _compute_cost} when determining the overall cost of traveling across a segment from a neighboring point to this point.
+   */
+  set_point_weight_scale(id: int, weight_scale: float): void;
+}

package/typings/classes/AStar3D.d.ts

@@ -0,0 +1,108 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * An implementation of A* for finding the shortest path between two vertices on a connected graph in 3D space.
+ */
+declare class AStar3D extends RefCounted {
+  /** If `true` enables the filtering of neighbors via {@link _filter_neighbor}. */
+  neighbor_filter_enabled: boolean;
+  set_neighbor_filter_enabled(value: boolean): void;
+  is_neighbor_filter_enabled(): boolean;
+
+  /**
+   * Called when computing the cost between two connected points.
+   * Note that this function is hidden in the default {@link AStar3D} class.
+   */
+  _compute_cost(from_id: int, to_id: int): float;
+  /**
+   * Called when estimating the cost between a point and the path's ending point.
+   * Note that this function is hidden in the default {@link AStar3D} class.
+   */
+  _estimate_cost(from_id: int, end_id: int): float;
+  /**
+   * Called when neighboring point enters processing and if {@link neighbor_filter_enabled} is `true`. If `true` is returned the point will not be processed.
+   * Note that this function is hidden in the default {@link AStar3D} class.
+   */
+  _filter_neighbor(from_id: int, neighbor_id: int): boolean;
+  /**
+   * Adds a new point at the given position with the given identifier. The `id` must be 0 or larger, and the `weight_scale` must be 0.0 or greater.
+   * The `weight_scale` is multiplied by the result of {@link _compute_cost} when determining the overall cost of traveling across a segment from a neighboring point to this point. Thus, all else being equal, the algorithm prefers points with lower `weight_scale`s to form a path.
+   * If there already exists a point for the given `id`, its position and weight scale are updated to the given values.
+   */
+  add_point(id: int, position: Vector3 | Vector3i, weight_scale?: float): void;
+  /**
+   * Returns whether the two given points are directly connected by a segment. If `bidirectional` is `false`, returns whether movement from `id` to `to_id` is possible through this segment.
+   */
+  are_points_connected(id: int, to_id: int, bidirectional?: boolean): boolean;
+  /** Clears all the points and segments. */
+  clear(): void;
+  /**
+   * Creates a segment between the given points. If `bidirectional` is `false`, only movement from `id` to `to_id` is allowed, not the reverse direction.
+   */
+  connect_points(id: int, to_id: int, bidirectional?: boolean): void;
+  /**
+   * Deletes the segment between the given points. If `bidirectional` is `false`, only movement from `id` to `to_id` is prevented, and a unidirectional segment possibly remains.
+   */
+  disconnect_points(id: int, to_id: int, bidirectional?: boolean): void;
+  /** Returns the next available point ID with no point associated to it. */
+  get_available_point_id(): int;
+  /**
+   * Returns the ID of the closest point to `to_position`, optionally taking disabled points into account. Returns `-1` if there are no points in the points pool.
+   * **Note:** If several points are the closest to `to_position`, the one with the smallest ID will be returned, ensuring a deterministic result.
+   */
+  get_closest_point(to_position: Vector3 | Vector3i, include_disabled?: boolean): int;
+  /**
+   * Returns the closest position to `to_position` that resides inside a segment between two connected points.
+   * The result is in the segment that goes from `y = 0` to `y = 5`. It's the closest position in the segment to the given point.
+   */
+  get_closest_position_in_segment(to_position: Vector3 | Vector3i): Vector3;
+  /**
+   * Returns an array with the IDs of the points that form the path found by AStar3D between the given points. The array is ordered from the starting point to the ending point of the path.
+   * If `from_id` point is disabled, returns an empty array (even if `from_id == to_id`).
+   * If `from_id` point is not disabled, there is no valid path to the target, and `allow_partial_path` is `true`, returns a path to the point closest to the target that can be reached.
+   * **Note:** When `allow_partial_path` is `true` and `to_id` is disabled the search may take an unusually long time to finish.
+   * If you change the 2nd point's weight to 3, then the result will be `[1, 4, 3]` instead, because now even though the distance is longer, it's "easier" to get through point 4 than through point 2.
+   */
+  get_id_path(from_id: int, to_id: int, allow_partial_path?: boolean): PackedInt64Array;
+  /**
+   * Returns the capacity of the structure backing the points, useful in conjunction with {@link reserve_space}.
+   */
+  get_point_capacity(): int;
+  /** Returns an array with the IDs of the points that form the connection with the given point. */
+  get_point_connections(id: int): PackedInt64Array;
+  /** Returns the number of points currently in the points pool. */
+  get_point_count(): int;
+  /** Returns an array of all point IDs. */
+  get_point_ids(): PackedInt64Array;
+  /**
+   * Returns an array with the points that are in the path found by AStar3D between the given points. The array is ordered from the starting point to the ending point of the path.
+   * If `from_id` point is disabled, returns an empty array (even if `from_id == to_id`).
+   * If `from_id` point is not disabled, there is no valid path to the target, and `allow_partial_path` is `true`, returns a path to the point closest to the target that can be reached.
+   * **Note:** This method is not thread-safe; it can only be used from a single {@link Thread} at a given time. Consider using {@link Mutex} to ensure exclusive access to one thread to avoid race conditions.
+   * Additionally, when `allow_partial_path` is `true` and `to_id` is disabled the search may take an unusually long time to finish.
+   */
+  get_point_path(from_id: int, to_id: int, allow_partial_path?: boolean): PackedVector3Array;
+  /** Returns the position of the point associated with the given `id`. */
+  get_point_position(id: int): Vector3;
+  /** Returns the weight scale of the point associated with the given `id`. */
+  get_point_weight_scale(id: int): float;
+  /** Returns whether a point associated with the given `id` exists. */
+  has_point(id: int): boolean;
+  /** Returns whether a point is disabled or not for pathfinding. By default, all points are enabled. */
+  is_point_disabled(id: int): boolean;
+  /** Removes the point associated with the given `id` from the points pool. */
+  remove_point(id: int): void;
+  /**
+   * Reserves space internally for `num_nodes` points. Useful if you're adding a known large number of points at once, such as points on a grid.
+   */
+  reserve_space(num_nodes: int): void;
+  /** Disables or enables the specified point for pathfinding. Useful for making a temporary obstacle. */
+  set_point_disabled(id: int, disabled?: boolean): void;
+  /** Sets the `position` for the point with the given `id`. */
+  set_point_position(id: int, position: Vector3 | Vector3i): void;
+  /**
+   * Sets the `weight_scale` for the point with the given `id`. The `weight_scale` is multiplied by the result of {@link _compute_cost} when determining the overall cost of traveling across a segment from a neighboring point to this point.
+   */
+  set_point_weight_scale(id: int, weight_scale: float): void;
+}

package/typings/classes/AStarGrid2D.d.ts

@@ -0,0 +1,184 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An implementation of A* for finding the shortest path between two points on a partial 2D grid. */
+declare class AStarGrid2D extends RefCounted {
+  /**
+   * The cell shape. Affects how the positions are placed in the grid. If changed, {@link update} needs to be called before finding the next path.
+   */
+  cell_shape: int;
+  /**
+   * The size of the point cell which will be applied to calculate the resulting point position returned by {@link get_point_path}. If changed, {@link update} needs to be called before finding the next path.
+   */
+  cell_size: Vector2;
+  /**
+   * The default {@link Heuristic} which will be used to calculate the cost between two points if {@link _compute_cost} was not overridden.
+   */
+  default_compute_heuristic: int;
+  /**
+   * The default {@link Heuristic} which will be used to calculate the cost between the point and the end point if {@link _estimate_cost} was not overridden.
+   */
+  default_estimate_heuristic: int;
+  /**
+   * A specific {@link DiagonalMode} mode which will force the path to avoid or accept the specified diagonals.
+   */
+  diagonal_mode: int;
+  /**
+   * Enables or disables jumping to skip up the intermediate points and speeds up the searching algorithm.
+   * **Note:** Currently, toggling it on disables the consideration of weight scaling in pathfinding.
+   */
+  jumping_enabled: boolean;
+  /**
+   * The offset of the grid which will be applied to calculate the resulting point position returned by {@link get_point_path}. If changed, {@link update} needs to be called before finding the next path.
+   */
+  offset: Vector2;
+  /**
+   * The region of grid cells available for pathfinding. If changed, {@link update} needs to be called before finding the next path.
+   */
+  region: Rect2i;
+  /**
+   * The size of the grid (number of cells of size {@link cell_size} on each axis). If changed, {@link update} needs to be called before finding the next path.
+   */
+  size: Vector2i;
+  set_cell_shape(value: int): void;
+  get_cell_shape(): int;
+  set_cell_size(value: Vector2 | Vector2i): void;
+  get_cell_size(): Vector2;
+  set_default_compute_heuristic(value: int): void;
+  get_default_compute_heuristic(): int;
+  set_default_estimate_heuristic(value: int): void;
+  get_default_estimate_heuristic(): int;
+  set_diagonal_mode(value: int): void;
+  get_diagonal_mode(): int;
+  set_jumping_enabled(value: boolean): void;
+  is_jumping_enabled(): boolean;
+  set_offset(value: Vector2 | Vector2i): void;
+  get_offset(): Vector2;
+  set_region(value: Rect2i | Rect2): void;
+  get_region(): Rect2i;
+  set_size(value: Vector2i | Vector2): void;
+  get_size(): Vector2i;
+
+  /**
+   * Called when computing the cost between two connected points.
+   * Note that this function is hidden in the default {@link AStarGrid2D} class.
+   */
+  _compute_cost(from_id: Vector2i | Vector2, to_id: Vector2i | Vector2): float;
+  /**
+   * Called when estimating the cost between a point and the path's ending point.
+   * Note that this function is hidden in the default {@link AStarGrid2D} class.
+   */
+  _estimate_cost(from_id: Vector2i | Vector2, end_id: Vector2i | Vector2): float;
+  /** Clears the grid and sets the {@link region} to `Rect2i(0, 0, 0, 0)`. */
+  clear(): void;
+  /**
+   * Fills the given `region` on the grid with the specified value for the solid flag.
+   * **Note:** Calling {@link update} is not needed after the call of this function.
+   */
+  fill_solid_region(region: Rect2i | Rect2, solid?: boolean): void;
+  /**
+   * Fills the given `region` on the grid with the specified value for the weight scale.
+   * **Note:** Calling {@link update} is not needed after the call of this function.
+   */
+  fill_weight_scale_region(region: Rect2i | Rect2, weight_scale: float): void;
+  /**
+   * Returns an array with the IDs of the points that form the path found by AStar2D between the given points. The array is ordered from the starting point to the ending point of the path.
+   * If `from_id` point is disabled, returns an empty array (even if `from_id == to_id`).
+   * If `from_id` point is not disabled, there is no valid path to the target, and `allow_partial_path` is `true`, returns a path to the point closest to the target that can be reached.
+   * **Note:** When `allow_partial_path` is `true` and `to_id` is solid the search may take an unusually long time to finish.
+   */
+  get_id_path(from_id: Vector2i | Vector2, to_id: Vector2i | Vector2, allow_partial_path?: boolean): Array<Vector2i>;
+  /**
+   * Returns an array of dictionaries with point data (`id`: {@link Vector2i}, `position`: {@link Vector2}, `solid`: [bool], `weight_scale`: [float]) within a `region`.
+   */
+  get_point_data_in_region(region: Rect2i | Rect2): Array<Dictionary>;
+  /**
+   * Returns an array with the points that are in the path found by {@link AStarGrid2D} between the given points. The array is ordered from the starting point to the ending point of the path.
+   * If `from_id` point is disabled, returns an empty array (even if `from_id == to_id`).
+   * If `from_id` point is not disabled, there is no valid path to the target, and `allow_partial_path` is `true`, returns a path to the point closest to the target that can be reached.
+   * **Note:** This method is not thread-safe; it can only be used from a single {@link Thread} at a given time. Consider using {@link Mutex} to ensure exclusive access to one thread to avoid race conditions.
+   * Additionally, when `allow_partial_path` is `true` and `to_id` is solid the search may take an unusually long time to finish.
+   */
+  get_point_path(from_id: Vector2i | Vector2, to_id: Vector2i | Vector2, allow_partial_path?: boolean): PackedVector2Array;
+  /** Returns the position of the point associated with the given `id`. */
+  get_point_position(id: Vector2i | Vector2): Vector2;
+  /** Returns the weight scale of the point associated with the given `id`. */
+  get_point_weight_scale(id: Vector2i | Vector2): float;
+  /** Indicates that the grid parameters were changed and {@link update} needs to be called. */
+  is_dirty(): boolean;
+  /**
+   * Returns `true` if the `x` and `y` is a valid grid coordinate (id), i.e. if it is inside {@link region}. Equivalent to `region.has_point(Vector2i(x, y))`.
+   */
+  is_in_bounds(x: int, y: int): boolean;
+  /**
+   * Returns `true` if the `id` vector is a valid grid coordinate, i.e. if it is inside {@link region}. Equivalent to `region.has_point(id)`.
+   */
+  is_in_boundsv(id: Vector2i | Vector2): boolean;
+  /** Returns `true` if a point is disabled for pathfinding. By default, all points are enabled. */
+  is_point_solid(id: Vector2i | Vector2): boolean;
+  /**
+   * Disables or enables the specified point for pathfinding. Useful for making an obstacle. By default, all points are enabled.
+   * **Note:** Calling {@link update} is not needed after the call of this function.
+   */
+  set_point_solid(id: Vector2i | Vector2, solid?: boolean): void;
+  /**
+   * Sets the `weight_scale` for the point with the given `id`. The `weight_scale` is multiplied by the result of {@link _compute_cost} when determining the overall cost of traveling across a segment from a neighboring point to this point.
+   * **Note:** Calling {@link update} is not needed after the call of this function.
+   */
+  set_point_weight_scale(id: Vector2i | Vector2, weight_scale: float): void;
+  /**
+   * Updates the internal state of the grid according to the parameters to prepare it to search the path. Needs to be called if parameters like {@link region}, {@link cell_size} or {@link offset} are changed. {@link is_dirty} will return `true` if this is the case and this needs to be called.
+   * **Note:** All point data (solidity and weight scale) will be cleared.
+   */
+  update(): void;
+
+  // enum Heuristic
+  /**
+   * The Euclidean heuristic (https://en.wikipedia.org/wiki/Euclidean_distance) to be used for the pathfinding using the following formula:
+   * **Note:** This is also the internal heuristic used in {@link AStar3D} and {@link AStar2D} by default (with the inclusion of possible z-axis coordinate).
+   */
+  static readonly HEURISTIC_EUCLIDEAN: int;
+  /**
+   * The Manhattan heuristic (https://en.wikipedia.org/wiki/Taxicab_geometry) to be used for the pathfinding using the following formula:
+   * **Note:** This heuristic is intended to be used with 4-side orthogonal movements, provided by setting the {@link diagonal_mode} to {@link DIAGONAL_MODE_NEVER}.
+   */
+  static readonly HEURISTIC_MANHATTAN: int;
+  /** The Octile heuristic to be used for the pathfinding using the following formula: */
+  static readonly HEURISTIC_OCTILE: int;
+  /**
+   * The Chebyshev heuristic (https://en.wikipedia.org/wiki/Chebyshev_distance) to be used for the pathfinding using the following formula:
+   */
+  static readonly HEURISTIC_CHEBYSHEV: int;
+  /** Represents the size of the {@link Heuristic} enum. */
+  static readonly HEURISTIC_MAX: int;
+  // enum DiagonalMode
+  /**
+   * The pathfinding algorithm will ignore solid neighbors around the target cell and allow passing using diagonals.
+   */
+  static readonly DIAGONAL_MODE_ALWAYS: int;
+  /** The pathfinding algorithm will ignore all diagonals and the way will be always orthogonal. */
+  static readonly DIAGONAL_MODE_NEVER: int;
+  /**
+   * The pathfinding algorithm will avoid using diagonals if at least two obstacles have been placed around the neighboring cells of the specific path segment.
+   */
+  static readonly DIAGONAL_MODE_AT_LEAST_ONE_WALKABLE: int;
+  /**
+   * The pathfinding algorithm will avoid using diagonals if any obstacle has been placed around the neighboring cells of the specific path segment.
+   */
+  static readonly DIAGONAL_MODE_ONLY_IF_NO_OBSTACLES: int;
+  /** Represents the size of the {@link DiagonalMode} enum. */
+  static readonly DIAGONAL_MODE_MAX: int;
+  // enum CellShape
+  /** Rectangular cell shape. */
+  static readonly CELL_SHAPE_SQUARE: int;
+  /**
+   * Diamond cell shape (for isometric look). Cell coordinates layout where the horizontal axis goes up-right, and the vertical one goes down-right.
+   */
+  static readonly CELL_SHAPE_ISOMETRIC_RIGHT: int;
+  /**
+   * Diamond cell shape (for isometric look). Cell coordinates layout where the horizontal axis goes down-right, and the vertical one goes down-left.
+   */
+  static readonly CELL_SHAPE_ISOMETRIC_DOWN: int;
+  /** Represents the size of the {@link CellShape} enum. */
+  static readonly CELL_SHAPE_MAX: int;
+}