typescript-to-gdscript 0.1.0

package/typings/classes/RID.d.ts

@@ -0,0 +1,65 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A handle for a {@link Resource}'s unique identifier. */
+declare interface RID {
+  /** Returns the ID of the referenced low-level resource. */
+  get_id(): int;
+  /** Returns `true` if the {@link RID} is not `0`. */
+  is_valid(): boolean;
+
+  // Operator overloads
+  [__ops_ne]: { right: RID; ret: boolean };
+  [__ops_lt]: { right: RID; ret: boolean };
+  [__ops_lte]: { right: RID; ret: boolean };
+  [__ops_eq]: { right: RID; ret: boolean };
+  [__ops_gt]: { right: RID; ret: boolean };
+  [__ops_gte]: { right: RID; ret: boolean };
+
+  [__variant_converts]: RID;
+
+  // 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;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  set: never;
+  size: never;
+  sort: never;
+  values: never;
+}
+
+declare interface RIDConstructor {
+  readonly prototype: RID;
+  /** Constructs an empty {@link RID} with the invalid ID `0`. */
+  (): RID;
+  /** Constructs an {@link RID} as a copy of the given {@link RID}. */
+  (from_: RID): RID;
+}
+declare const RID: RIDConstructor;

package/typings/classes/RandomNumberGenerator.d.ts

@@ -0,0 +1,45 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides methods for generating pseudo-random numbers. */
+declare class RandomNumberGenerator extends RefCounted {
+  /**
+   * Initializes the random number generator state based on the given seed value. A given seed will give a reproducible sequence of pseudo-random numbers.
+   * **Note:** The RNG does not have an avalanche effect, and can output similar random streams given similar seeds. Consider using a hash function to improve your seed quality if they're sourced externally.
+   * **Note:** Setting this property produces a side effect of changing the internal {@link state}, so make sure to initialize the seed *before* modifying the {@link state}:
+   * **Note:** The default value of this property is pseudo-random, and changes when calling {@link randomize}. The `0` value documented here is a placeholder, and not the actual default seed.
+   */
+  seed: int;
+  /**
+   * The current state of the random number generator. Save and restore this property to restore the generator to a previous state:
+   * **Note:** Do not set state to arbitrary values, since the random number generator requires the state to have certain qualities to behave properly. It should only be set to values that came from the state property itself. To initialize the random number generator with arbitrary input, use {@link seed} instead.
+   * **Note:** The default value of this property is pseudo-random, and changes when calling {@link randomize}. The `0` value documented here is a placeholder, and not the actual default state.
+   */
+  state: int;
+  set_seed(value: int): void;
+  get_seed(): int;
+  set_state(value: int): void;
+  get_state(): int;
+
+  /**
+   * Returns a random index with non-uniform weights. Prints an error and returns `-1` if the array is empty.
+   */
+  rand_weighted(weights: PackedFloat32Array | Array<unknown>): int;
+  /** Returns a pseudo-random float between `0.0` and `1.0` (inclusive). */
+  randf(): float;
+  /** Returns a pseudo-random float between `from` and `to` (inclusive). */
+  randf_range(from_: float, to: float): float;
+  /**
+   * Returns a normally-distributed (https://en.wikipedia.org/wiki/Normal_distribution), pseudo-random floating-point number from the specified `mean` and a standard `deviation`. This is also known as a Gaussian distribution.
+   * **Note:** This method uses the Box-Muller transform (https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform) algorithm.
+   */
+  randfn(mean?: float, deviation?: float): float;
+  /** Returns a pseudo-random 32-bit unsigned integer between `0` and `4294967295` (inclusive). */
+  randi(): int;
+  /** Returns a pseudo-random 32-bit signed integer between `from` and `to` (inclusive). */
+  randi_range(from_: int, to: int): int;
+  /**
+   * Sets up a time-based seed for this {@link RandomNumberGenerator} instance. Unlike the [@GlobalScope] random number generation functions, different {@link RandomNumberGenerator} instances can use different seeds.
+   */
+  randomize(): void;
+}

package/typings/classes/Range.d.ts

@@ -0,0 +1,76 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for controls that represent a number within a range. */
+declare class Range extends Control {
+  /** If `true`, {@link value} may be greater than {@link max_value}. */
+  allow_greater: boolean;
+  /** If `true`, {@link value} may be less than {@link min_value}. */
+  allow_lesser: boolean;
+  /**
+   * If `true`, and {@link min_value} is greater or equal to `0`, {@link value} will be represented exponentially rather than linearly.
+   */
+  exp_edit: boolean;
+  /** Maximum value. Range is clamped if {@link value} is greater than {@link max_value}. */
+  max_value: float;
+  /** Minimum value. Range is clamped if {@link value} is less than {@link min_value}. */
+  min_value: float;
+  /**
+   * Page size. Used mainly for {@link ScrollBar}. A {@link ScrollBar}'s grabber length is the {@link ScrollBar}'s size multiplied by {@link page} over the difference between {@link min_value} and {@link max_value}.
+   */
+  page: float;
+  /** The value mapped between 0 and 1. */
+  ratio: float;
+  /** If `true`, {@link value} will always be rounded to the nearest integer. */
+  rounded: boolean;
+  /**
+   * <member name="step" type="float" setter="set_step" getter="get_step" default="0.01">
+   * If greater than `0.0`, {@link value} will always be rounded to a multiple of this property's value above {@link min_value}. For example, if {@link min_value} is `0.1` and step is `0.2`, then {@link value} is limited to `0.1`, `0.3`, `0.5`, and so on. If {@link rounded} is also `true`, {@link value} will first be rounded to a multiple of this property's value, then rounded to the nearest integer.
+   */
+  size_flags_vertical: int;
+  /**
+   * Range's current value. Changing this property (even via code) will trigger {@link value_changed} signal. Use {@link set_value_no_signal} if you want to avoid it.
+   */
+  value: float;
+  set_allow_greater(value: boolean): void;
+  is_greater_allowed(): boolean;
+  set_allow_lesser(value: boolean): void;
+  is_lesser_allowed(): boolean;
+  set_exp_ratio(value: boolean): void;
+  is_ratio_exp(): boolean;
+  set_max(value: float): void;
+  get_max(): float;
+  set_min(value: float): void;
+  get_min(): float;
+  set_page(value: float): void;
+  get_page(): float;
+  set_as_ratio(value: float): void;
+  get_as_ratio(): float;
+  set_use_rounded_values(value: boolean): void;
+  is_using_rounded_values(): boolean;
+  set_value(value: float): void;
+  get_value(): float;
+
+  /**
+   * Called when the {@link Range}'s value is changed (following the same conditions as {@link value_changed}).
+   */
+  _value_changed(new_value: float): void;
+  /**
+   * Sets the {@link Range}'s current value to the specified `value`, without emitting the {@link value_changed} signal.
+   */
+  set_value_no_signal(value: float): void;
+  /**
+   * Binds two {@link Range}s together along with any ranges previously grouped with either of them. When any of range's member variables change, it will share the new value with all other ranges in its group.
+   */
+  share(with_: Node): void;
+  /** Stops the {@link Range} from sharing its member variables with any other. */
+  unshare(): void;
+
+  /** Emitted when {@link min_value}, {@link max_value}, {@link page}, or {@link step} change. */
+  changed: Signal<[]>;
+  /**
+   * Emitted when {@link value} changes. When used on a {@link Slider}, this is called continuously while dragging (potentially every frame). If you are performing an expensive operation in a function connected to {@link value_changed}, consider using a *debouncing* {@link Timer} to call the function less often.
+   * **Note:** Unlike signals such as {@link LineEdit.text_changed}, {@link value_changed} is also emitted when `value` is set directly via code.
+   */
+  value_changed: Signal<[float]>;
+}

package/typings/classes/RayCast2D.d.ts

@@ -0,0 +1,90 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A ray in 2D space, used to find the first collision object it intersects. */
+declare class RayCast2D extends Node2D {
+  /** If `true`, collisions with {@link Area2D}s will be reported. */
+  collide_with_areas: boolean;
+  /** If `true`, collisions with {@link PhysicsBody2D}s will be reported. */
+  collide_with_bodies: boolean;
+  /**
+   * The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /** If `true`, collisions will be reported. */
+  enabled: boolean;
+  /**
+   * If `true`, this raycast will not report collisions with its parent node. This property only has an effect if the parent node is a {@link CollisionObject2D}. See also {@link Node.get_parent} and {@link add_exception}.
+   */
+  exclude_parent: boolean;
+  /**
+   * If `true`, the ray will detect a hit when starting inside shapes. In this case the collision normal will be `Vector2(0, 0)`. Does not affect concave polygon shapes.
+   */
+  hit_from_inside: boolean;
+  /** The ray's destination point, relative to this raycast's {@link Node2D.position}. */
+  target_position: Vector2;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_exclude_parent_body(value: boolean): void;
+  get_exclude_parent_body(): boolean;
+  set_hit_from_inside(value: boolean): void;
+  is_hit_from_inside_enabled(): boolean;
+  set_target_position(value: Vector2 | Vector2i): void;
+  get_target_position(): Vector2;
+
+  /** Adds a collision exception so the ray does not report collisions with the specified `node`. */
+  add_exception(node: CollisionObject2D): void;
+  /** Adds a collision exception so the ray does not report collisions with the specified {@link RID}. */
+  add_exception_rid(rid: RID): void;
+  /** Removes all collision exceptions for this ray. */
+  clear_exceptions(): void;
+  /**
+   * Updates the collision information for the ray immediately, without waiting for the next `_physics_process` call. Use this method, for example, when the ray or its parent has changed state.
+   * **Note:** {@link enabled} does not need to be `true` for this to work.
+   */
+  force_raycast_update(): void;
+  /**
+   * Returns the first object that the ray intersects, or `null` if no object is intersecting the ray (i.e. {@link is_colliding} returns `false`).
+   * **Note:** This object is not guaranteed to be a {@link CollisionObject2D}. For example, if the ray intersects a {@link TileMapLayer}, the method will return a {@link TileMapLayer} instance.
+   */
+  get_collider(): GodotObject | null;
+  /**
+   * Returns the {@link RID} of the first object that the ray intersects, or an empty {@link RID} if no object is intersecting the ray (i.e. {@link is_colliding} returns `false`).
+   */
+  get_collider_rid(): RID;
+  /**
+   * Returns the shape ID of the first object that the ray intersects, or `0` if no object is intersecting the ray (i.e. {@link is_colliding} returns `false`).
+   * To get the intersected shape node, for a {@link CollisionObject2D} target, use:
+   */
+  get_collider_shape(): int;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_mask_value(layer_number: int): boolean;
+  /**
+   * Returns the normal of the intersecting object's shape at the collision point, or `Vector2(0, 0)` if the ray starts inside the shape and {@link hit_from_inside} is `true`.
+   * **Note:** Check that {@link is_colliding} returns `true` before calling this method to ensure the returned normal is valid and up-to-date.
+   */
+  get_collision_normal(): Vector2;
+  /**
+   * Returns the collision point at which the ray intersects the closest object, in the global coordinate system. If {@link hit_from_inside} is `true` and the ray starts inside of a collision shape, this function will return the origin point of the ray.
+   * **Note:** Check that {@link is_colliding} returns `true` before calling this method to ensure the returned point is valid and up-to-date.
+   */
+  get_collision_point(): Vector2;
+  /** Returns whether any object is intersecting with the ray's vector (considering the vector length). */
+  is_colliding(): boolean;
+  /** Removes a collision exception so the ray can report collisions with the specified `node`. */
+  remove_exception(node: CollisionObject2D): void;
+  /** Removes a collision exception so the ray can report collisions with the specified {@link RID}. */
+  remove_exception_rid(rid: RID): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_mask_value(layer_number: int, value: boolean): void;
+}

package/typings/classes/RayCast3D.d.ts

@@ -0,0 +1,113 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A ray in 3D space, used to find the first collision object it intersects. */
+declare class RayCast3D extends Node3D {
+  /** If `true`, collisions with {@link Area3D}s will be reported. */
+  collide_with_areas: boolean;
+  /** If `true`, collisions with {@link PhysicsBody3D}s will be reported. */
+  collide_with_bodies: boolean;
+  /**
+   * The ray's collision mask. Only objects in at least one collision layer enabled in the mask will be detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * The custom color to use to draw the shape in the editor and at run-time if **Visible Collision Shapes** is enabled in the **Debug** menu. This color will be highlighted at run-time if the {@link RayCast3D} is colliding with something.
+   * If set to `Color(0.0, 0.0, 0.0)` (by default), the color set in {@link ProjectSettings.debug/shapes/collision/shape_color} is used.
+   */
+  debug_shape_custom_color: Color;
+  /**
+   * If set to `1`, a line is used as the debug shape. Otherwise, a truncated pyramid is drawn to represent the {@link RayCast3D}. Requires **Visible Collision Shapes** to be enabled in the **Debug** menu for the debug shape to be visible at run-time.
+   */
+  debug_shape_thickness: int;
+  /** If `true`, collisions will be reported. */
+  enabled: boolean;
+  /**
+   * If `true`, this raycast will not report collisions with its parent node. This property only has an effect if the parent node is a {@link CollisionObject3D}. See also {@link Node.get_parent} and {@link add_exception}.
+   */
+  exclude_parent: boolean;
+  /**
+   * If `true`, the ray will hit back faces with concave polygon shapes with back face enabled or heightmap shapes.
+   */
+  hit_back_faces: boolean;
+  /**
+   * If `true`, the ray will detect a hit when starting inside shapes. In this case the collision normal will be `Vector3(0, 0, 0)`. Does not affect shapes with no volume like concave polygon or heightmap.
+   */
+  hit_from_inside: boolean;
+  /** The ray's destination point, relative to this raycast's {@link Node3D.position}. */
+  target_position: Vector3;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_debug_shape_custom_color(value: Color): void;
+  get_debug_shape_custom_color(): Color;
+  set_debug_shape_thickness(value: int): void;
+  get_debug_shape_thickness(): int;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_exclude_parent_body(value: boolean): void;
+  get_exclude_parent_body(): boolean;
+  set_hit_back_faces(value: boolean): void;
+  is_hit_back_faces_enabled(): boolean;
+  set_hit_from_inside(value: boolean): void;
+  is_hit_from_inside_enabled(): boolean;
+  set_target_position(value: Vector3 | Vector3i): void;
+  get_target_position(): Vector3;
+
+  /** Adds a collision exception so the ray does not report collisions with the specified `node`. */
+  add_exception(node: CollisionObject3D): void;
+  /** Adds a collision exception so the ray does not report collisions with the specified {@link RID}. */
+  add_exception_rid(rid: RID): void;
+  /** Removes all collision exceptions for this ray. */
+  clear_exceptions(): void;
+  /**
+   * Updates the collision information for the ray immediately, without waiting for the next `_physics_process` call. Use this method, for example, when the ray or its parent has changed state.
+   * **Note:** {@link enabled} does not need to be `true` for this to work.
+   */
+  force_raycast_update(): void;
+  /**
+   * Returns the first object that the ray intersects, or `null` if no object is intersecting the ray (i.e. {@link is_colliding} returns `false`).
+   * **Note:** This object is not guaranteed to be a {@link CollisionObject3D}. For example, if the ray intersects a {@link CSGShape3D} or a {@link GridMap}, the method will return a {@link CSGShape3D} or {@link GridMap} instance.
+   */
+  get_collider(): GodotObject | null;
+  /**
+   * Returns the {@link RID} of the first object that the ray intersects, or an empty {@link RID} if no object is intersecting the ray (i.e. {@link is_colliding} returns `false`).
+   */
+  get_collider_rid(): RID;
+  /**
+   * Returns the shape ID of the first object that the ray intersects, or `0` if no object is intersecting the ray (i.e. {@link is_colliding} returns `false`).
+   * To get the intersected shape node, for a {@link CollisionObject3D} target, use:
+   */
+  get_collider_shape(): int;
+  /**
+   * Returns the collision object's face index at the collision point, or `-1` if the shape intersecting the ray is not a {@link ConcavePolygonShape3D}.
+   */
+  get_collision_face_index(): int;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_mask_value(layer_number: int): boolean;
+  /**
+   * Returns the normal of the intersecting object's shape at the collision point, or `Vector3(0, 0, 0)` if the ray starts inside the shape and {@link hit_from_inside} is `true`.
+   * **Note:** Check that {@link is_colliding} returns `true` before calling this method to ensure the returned normal is valid and up-to-date.
+   */
+  get_collision_normal(): Vector3;
+  /**
+   * Returns the collision point at which the ray intersects the closest object, in the global coordinate system. If {@link hit_from_inside} is `true` and the ray starts inside of a collision shape, this function will return the origin point of the ray.
+   * **Note:** Check that {@link is_colliding} returns `true` before calling this method to ensure the returned point is valid and up-to-date.
+   */
+  get_collision_point(): Vector3;
+  /** Returns whether any object is intersecting with the ray's vector (considering the vector length). */
+  is_colliding(): boolean;
+  /** Removes a collision exception so the ray can report collisions with the specified `node`. */
+  remove_exception(node: CollisionObject3D): void;
+  /** Removes a collision exception so the ray can report collisions with the specified {@link RID}. */
+  remove_exception_rid(rid: RID): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_mask_value(layer_number: int, value: boolean): void;
+}

package/typings/classes/Rect2.d.ts

@@ -0,0 +1,135 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D axis-aligned bounding box using floating-point coordinates. */
+declare interface Rect2 {
+  /**
+   * The ending point. This is usually the bottom-right corner of the rectangle, and is equivalent to `position + size`. Setting this point affects the {@link size}.
+   */
+  end: Vector2;
+  /** The origin point. This is usually the top-left corner of the rectangle. */
+  position: Vector2;
+  /**
+   * The rectangle's width and height, starting from {@link position}. Setting this value also affects the {@link end} point.
+   * **Note:** It's recommended setting the width and height to non-negative values, as most methods in Godot assume that the {@link position} is the top-left corner, and the {@link end} is the bottom-right corner. To get an equivalent rectangle with non-negative size, use {@link abs}.
+   */
+  size: Vector2;
+
+  /**
+   * Returns a {@link Rect2} equivalent to this rectangle, with its width and height modified to be non-negative values, and with its {@link position} being the top-left corner of the rectangle.
+   * **Note:** It's recommended to use this method when {@link size} is negative, as most other methods in Godot assume that the {@link position} is the top-left corner, and the {@link end} is the bottom-right corner.
+   */
+  abs(): Rect2;
+  /** Returns `true` if this rectangle *completely* encloses the `b` rectangle. */
+  encloses(b: Rect2 | Rect2i): boolean;
+  /**
+   * Returns a copy of this rectangle expanded to align the edges with the given `to` point, if necessary.
+   */
+  expand(to: Vector2 | Vector2i): Rect2;
+  /** Returns the rectangle's area. This is equivalent to `size.x * size.y`. See also {@link has_area}. */
+  get_area(): float;
+  /** Returns the center point of the rectangle. This is the same as `position + (size / 2.0)`. */
+  get_center(): Vector2;
+  /**
+   * Returns the vertex's position of this rect that's the farthest in the given direction. This point is commonly known as the support point in collision detection algorithms.
+   */
+  get_support(direction: Vector2 | Vector2i): Vector2;
+  /**
+   * Returns a copy of this rectangle extended on all sides by the given `amount`. A negative `amount` shrinks the rectangle instead. See also {@link grow_individual} and {@link grow_side}.
+   */
+  grow(amount: float): Rect2;
+  /**
+   * Returns a copy of this rectangle with its `left`, `top`, `right`, and `bottom` sides extended by the given amounts. Negative values shrink the sides, instead. See also {@link grow} and {@link grow_side}.
+   */
+  grow_individual(left: float, top: float, right: float, bottom: float): Rect2;
+  /**
+   * Returns a copy of this rectangle with its `side` extended by the given `amount` (see {@link Side} constants). A negative `amount` shrinks the rectangle, instead. See also {@link grow} and {@link grow_individual}.
+   */
+  grow_side(side: int, amount: float): Rect2;
+  /** Returns `true` if this rectangle has positive width and height. See also {@link get_area}. */
+  has_area(): boolean;
+  /**
+   * Returns `true` if the rectangle contains the given `point`. By convention, points on the right and bottom edges are **not** included.
+   * **Note:** This method is not reliable for {@link Rect2} with a *negative* {@link size}. Use {@link abs} first to get a valid rectangle.
+   */
+  has_point(point: Vector2 | Vector2i): boolean;
+  /**
+   * Returns the intersection between this rectangle and `b`. If the rectangles do not intersect, returns an empty {@link Rect2}.
+   * **Note:** If you only need to know whether two rectangles are overlapping, use {@link intersects}, instead.
+   */
+  intersection(b: Rect2 | Rect2i): Rect2;
+  /**
+   * Returns `true` if this rectangle overlaps with the `b` rectangle. The edges of both rectangles are excluded, unless `include_borders` is `true`.
+   */
+  intersects(b: Rect2 | Rect2i, include_borders?: boolean): boolean;
+  /**
+   * Returns `true` if this rectangle and `rect` are approximately equal, by calling {@link Vector2.is_equal_approx} on the {@link position} and the {@link size}.
+   */
+  is_equal_approx(rect: Rect2 | Rect2i): boolean;
+  /**
+   * Returns `true` if this rectangle's values are finite, by calling {@link Vector2.is_finite} on the {@link position} and the {@link size}.
+   */
+  is_finite(): boolean;
+  /**
+   * Returns a {@link Rect2} that encloses both this rectangle and `b` around the edges. See also {@link encloses}.
+   */
+  merge(b: Rect2 | Rect2i): Rect2;
+
+  // Operator overloads
+  [__ops_ne]: { right: Rect2; ret: boolean };
+  [__ops_mul]: { right: Transform2D; ret: Rect2 };
+  [__ops_eq]: { right: Rect2; ret: boolean };
+
+  [__variant_converts]: Rect2 | Rect2i;
+
+  // 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 Rect2Constructor {
+  readonly prototype: Rect2;
+  /** Constructs a {@link Rect2} with its {@link position} and {@link size} set to {@link Vector2.ZERO}. */
+  (): Rect2;
+  /** Constructs a {@link Rect2} as a copy of the given {@link Rect2}. */
+  (from_: Rect2): Rect2;
+  /** Constructs a {@link Rect2} from a {@link Rect2i}. */
+  (from_: Rect2i): Rect2;
+  /** Constructs a {@link Rect2} by `position` and `size`. */
+  (position: Vector2, size: Vector2): Rect2;
+  /**
+   * Constructs a {@link Rect2} by setting its {@link position} to (`x`, `y`), and its {@link size} to (`width`, `height`).
+   */
+  (x: float, y: float, width: float, height: float): Rect2;
+}
+declare const Rect2: Rect2Constructor;

package/typings/classes/Rect2i.d.ts

@@ -0,0 +1,127 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D axis-aligned bounding box using integer coordinates. */
+declare interface Rect2i {
+  /**
+   * The ending point. This is usually the bottom-right corner of the rectangle, and is equivalent to `position + size`. Setting this point affects the {@link size}.
+   */
+  end: Vector2i;
+  /** The origin point. This is usually the top-left corner of the rectangle. */
+  position: Vector2i;
+  /**
+   * The rectangle's width and height, starting from {@link position}. Setting this value also affects the {@link end} point.
+   * **Note:** It's recommended setting the width and height to non-negative values, as most methods in Godot assume that the {@link position} is the top-left corner, and the {@link end} is the bottom-right corner. To get an equivalent rectangle with non-negative size, use {@link abs}.
+   */
+  size: Vector2i;
+
+  /**
+   * Returns a {@link Rect2i} equivalent to this rectangle, with its width and height modified to be non-negative values, and with its {@link position} being the top-left corner of the rectangle.
+   * **Note:** It's recommended to use this method when {@link size} is negative, as most other methods in Godot assume that the {@link position} is the top-left corner, and the {@link end} is the bottom-right corner.
+   */
+  abs(): Rect2i;
+  /** Returns `true` if this {@link Rect2i} completely encloses another one. */
+  encloses(b: Rect2i | Rect2): boolean;
+  /**
+   * Returns a copy of this rectangle expanded to align the edges with the given `to` point, if necessary.
+   */
+  expand(to: Vector2i | Vector2): Rect2i;
+  /** Returns the rectangle's area. This is equivalent to `size.x * size.y`. See also {@link has_area}. */
+  get_area(): int;
+  /**
+   * Returns the center point of the rectangle. This is the same as `position + (size / 2)`.
+   * **Note:** If the {@link size} is odd, the result will be rounded towards {@link position}.
+   */
+  get_center(): Vector2i;
+  /**
+   * Returns a copy of this rectangle extended on all sides by the given `amount`. A negative `amount` shrinks the rectangle instead. See also {@link grow_individual} and {@link grow_side}.
+   */
+  grow(amount: int): Rect2i;
+  /**
+   * Returns a copy of this rectangle with its `left`, `top`, `right`, and `bottom` sides extended by the given amounts. Negative values shrink the sides, instead. See also {@link grow} and {@link grow_side}.
+   */
+  grow_individual(left: int, top: int, right: int, bottom: int): Rect2i;
+  /**
+   * Returns a copy of this rectangle with its `side` extended by the given `amount` (see {@link Side} constants). A negative `amount` shrinks the rectangle, instead. See also {@link grow} and {@link grow_individual}.
+   */
+  grow_side(side: int, amount: int): Rect2i;
+  /** Returns `true` if this rectangle has positive width and height. See also {@link get_area}. */
+  has_area(): boolean;
+  /**
+   * Returns `true` if the rectangle contains the given `point`. By convention, points on the right and bottom edges are **not** included.
+   * **Note:** This method is not reliable for {@link Rect2i} with a *negative* {@link size}. Use {@link abs} first to get a valid rectangle.
+   */
+  has_point(point: Vector2i | Vector2): boolean;
+  /**
+   * Returns the intersection between this rectangle and `b`. If the rectangles do not intersect, returns an empty {@link Rect2i}.
+   * **Note:** If you only need to know whether two rectangles are overlapping, use {@link intersects}, instead.
+   */
+  intersection(b: Rect2i | Rect2): Rect2i;
+  /**
+   * Returns `true` if this rectangle overlaps with the `b` rectangle. The edges of both rectangles are excluded.
+   */
+  intersects(b: Rect2i | Rect2): boolean;
+  /**
+   * Returns a {@link Rect2i} that encloses both this rectangle and `b` around the edges. See also {@link encloses}.
+   */
+  merge(b: Rect2i | Rect2): Rect2i;
+
+  // Operator overloads
+  [__ops_ne]: { right: Rect2i; ret: boolean };
+  [__ops_eq]: { right: Rect2i; ret: boolean };
+
+  [__variant_converts]: Rect2i | Rect2;
+
+  // 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 Rect2iConstructor {
+  readonly prototype: Rect2i;
+  /**
+   * Constructs a {@link Rect2i} with its {@link position} and {@link size} set to {@link Vector2i.ZERO}.
+   */
+  (): Rect2i;
+  /** Constructs a {@link Rect2i} as a copy of the given {@link Rect2i}. */
+  (from_: Rect2i): Rect2i;
+  /** Constructs a {@link Rect2i} from a {@link Rect2}. The floating-point coordinates are truncated. */
+  (from_: Rect2): Rect2i;
+  /** Constructs a {@link Rect2i} by `position` and `size`. */
+  (position: Vector2i, size: Vector2i): Rect2i;
+  /**
+   * Constructs a {@link Rect2i} by setting its {@link position} to (`x`, `y`), and its {@link size} to (`width`, `height`).
+   */
+  (x: int, y: int, width: int, height: int): Rect2i;
+}
+declare const Rect2i: Rect2iConstructor;

package/typings/classes/RectangleShape2D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D rectangle shape used for physics collision. */
+declare class RectangleShape2D extends Shape2D {
+  /** The rectangle's width and height. */
+  size: Vector2;
+  set_size(value: Vector2 | Vector2i): void;
+  get_size(): Vector2;
+}