@ringozz/godot 0.1.0

package/gen/value-types/Quaternion.ts

@@ -0,0 +1,192 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
+import type { Basis, Vector3 } from '../value-types/index.ts';
+
+/**
+ * The {@link Quaternion} built-in {@link Variant} type is a 4D data structure that represents rotation in the form of a [Hamilton convention quaternion](https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation). Compared to the {@link Basis} type which can store both rotation and scale, quaternions can *only* store rotation.
+ * A {@link Quaternion} is composed by 4 floating-point components: {@link w}, {@link x}, {@link y}, and {@link z}. These components are very compact in memory, and because of this some operations are more efficient and less likely to cause floating-point errors. Methods such as {@link getAngle}, {@link getAxis}, and {@link slerp} are faster than their {@link Basis} counterparts.
+ * For a great introduction to quaternions, see [this video by 3Blue1Brown](https://www.youtube.com/watch?v=d4EgbgTm0Bg). You do not need to know the math behind quaternions, as Godot provides several helper methods that handle it for you. These include {@link slerp} and {@link sphericalCubicInterpolate}, as well as the `*` operator.
+ * **Note:** Quaternions must be normalized before being used for rotation (see {@link normalized}).
+ * **Note:** Similarly to {@link Vector2} and {@link Vector3}, the components of a quaternion use 32-bit precision by default, unlike {@link float} which is always 64-bit. If double precision is needed, compile the engine with the option `precision=double`.
+ * **Note:** In a boolean context, a quaternion will evaluate to `false` if it's equal to {@link IDENTITY}. Otherwise, a quaternion will always evaluate to `true`.
+ */
+export class Quaternion extends GodotVar {
+    /**
+     * X component of the quaternion. This is the value along the "imaginary" `i` axis.
+     * **Note:** Quaternion components should usually not be manipulated directly.
+     */
+    get x(): number { return _get(this, 14941) as number; }
+    set x(v: number) { _set(this, 14941, v); }
+
+    /**
+     * Y component of the quaternion. This is the value along the "imaginary" `j` axis.
+     * **Note:** Quaternion components should usually not be manipulated directly.
+     */
+    get y(): number { return _get(this, 14952) as number; }
+    set y(v: number) { _set(this, 14952, v); }
+
+    /**
+     * Z component of the quaternion. This is the value along the "imaginary" `k` axis.
+     * **Note:** Quaternion components should usually not be manipulated directly.
+     */
+    get z(): number { return _get(this, 14956) as number; }
+    set z(v: number) { _set(this, 14956, v); }
+
+    /**
+     * W component of the quaternion. This is the "real" part.
+     * **Note:** Quaternion components should usually not be manipulated directly.
+     */
+    get w(): number { return _get(this, 14833) as number; }
+    set w(v: number) { _set(this, 14833, v); }
+
+    constructor();
+    constructor(from: Quaternion);
+    constructor(from: Basis);
+    constructor(axis: Vector3, angle: number);
+    constructor(arcFrom: Vector3, arcTo: Vector3);
+    constructor(x: number, y: number, z: number, w: number);
+    constructor(...args: any[]) { super(15, ...args); }
+
+    /**
+     * Returns this quaternion's length, also called magnitude.
+     */
+    length(): number { return _C(this, 8546) as number; }
+
+    /**
+     * Returns this quaternion's length, squared.
+     * **Note:** This method is faster than {@link length}, so prefer it if you only need to compare quaternion lengths.
+     */
+    lengthSquared(): number { return _C(this, 8547) as number; }
+
+    /**
+     * Returns a copy of this quaternion, normalized so that its length is `1.0`. See also {@link isNormalized}.
+     */
+    normalized(): Quaternion { return _C(this, 9103) as Quaternion; }
+
+    /**
+     * Returns `true` if this quaternion is normalized. See also {@link normalized}.
+     */
+    isNormalized(): boolean { return _C(this, 8138) as boolean; }
+
+    /**
+     * Returns `true` if this quaternion and `to` are approximately equal, by calling {@link isEqualApprox} on each component.
+     */
+    isEqualApprox(to: Quaternion): boolean { return _C(this, 7938, to) as boolean; }
+
+    /**
+     * Returns `true` if this quaternion is finite, by calling {@link isFinite} on each component.
+     */
+    isFinite(): boolean { return _C(this, 7951) as boolean; }
+
+    /**
+     * Returns the inverse version of this quaternion, inverting the sign of every component except {@link w}.
+     */
+    inverse(): Quaternion { return _C(this, 7714) as Quaternion; }
+
+    /**
+     * Returns the logarithm of this quaternion. Multiplies this quaternion's rotation axis by its rotation angle, and stores the result in the returned quaternion's vector part ({@link x}, {@link y}, and {@link z}). The returned quaternion's real part ({@link w}) is always `0.0`.
+     */
+    log(): Quaternion { return _C(this, 8704) as Quaternion; }
+
+    /**
+     * Returns the exponential of this quaternion. The rotation axis of the result is the normalized rotation axis of this quaternion, the angle of the result is the length of the vector part of this quaternion.
+     */
+    exp(): Quaternion { return _C(this, 3185) as Quaternion; }
+
+    /**
+     * Returns the angle between this quaternion and `to`. This is the magnitude of the angle you would need to rotate by to get from one to the other.
+     * **Note:** The magnitude of the floating-point error for this method is abnormally high, so methods such as `is_zero_approx` will not work reliably.
+     */
+    angleTo(to: Quaternion): number { return _C(this, 1453, to) as number; }
+
+    /**
+     * Returns the dot product between this quaternion and `with`.
+     * This is equivalent to `(quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w)`.
+     */
+    dot(_with: Quaternion): number { return _C(this, 2871, _with) as number; }
+
+    /**
+     * Performs a spherical-linear interpolation with the `to` quaternion, given a `weight` and returns the result. Both this quaternion and `to` must be normalized.
+     */
+    slerp(to: Quaternion, weight: number): Quaternion { return _C(this, 13656, to, weight) as Quaternion; }
+
+    /**
+     * Performs a spherical-linear interpolation with the `to` quaternion, given a `weight` and returns the result. Unlike {@link slerp}, this method does not check if the rotation path is smaller than 90 degrees. Both this quaternion and `to` must be normalized.
+     */
+    slerpni(to: Quaternion, weight: number): Quaternion { return _C(this, 13657, to, weight) as Quaternion; }
+
+    /**
+     * Performs a spherical cubic interpolation between quaternions `preA`, this vector, `b`, and `postB`, by the given amount `weight`.
+     */
+    sphericalCubicInterpolate(b: Quaternion, preA: Quaternion, postB: Quaternion, weight: number): Quaternion { return _C(this, 13780, b, preA, postB, weight) as Quaternion; }
+
+    /**
+     * Performs a spherical cubic interpolation between quaternions `preA`, this vector, `b`, and `postB`, by the given amount `weight`.
+     * It can perform smoother interpolation than {@link sphericalCubicInterpolate} by the time values.
+     */
+    sphericalCubicInterpolateInTime(b: Quaternion, preA: Quaternion, postB: Quaternion, weight: number, bT: number, preAT: number, postBT: number): Quaternion { return _C(this, 13781, b, preA, postB, weight, bT, preAT, postBT) as Quaternion; }
+
+    /**
+     * Returns this quaternion's rotation as a {@link Vector3} of [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians.
+     * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). In Godot, Euler angles always use intrinsic order. By default, the intrinsic YXZ convention is used ({@link EULER_ORDER_YXZ}): since we are decomposing, local Z (roll) is calculated first, then local X (pitch), and lastly local Y (yaw). When using the opposite method {@link fromEuler} to compose a rotation, this order is reversed.
+     */
+    getEuler(order?: number /* = 2 */): Vector3 { return _C(this, 4689, order) as Vector3; }
+
+    /**
+     * Returns the rotation axis of the rotation represented by this quaternion.
+     */
+    getAxis(): Vector3 { return _C(this, 3859) as Vector3; }
+
+    /**
+     * Returns the angle of the rotation represented by this quaternion.
+     * **Note:** The quaternion must be normalized.
+     */
+    getAngle(): number { return _C(this, 3749) as number; }
+
+    equals(other: Variant | Quaternion): boolean { return _C(this, -1, other) as boolean; }
+
+    notEquals(other: Variant | Quaternion): boolean { return _C(this, -2, other) as boolean; }
+
+    /**
+     * Returns the negative value of the {@link Quaternion}. This is the same as multiplying all components by `-1`. This operation results in a quaternion that represents the same rotation.
+     */
+    neg(): Quaternion { return _C(this, -11, undefined) as Quaternion; }
+
+    /**
+     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
+     */
+    pos(): Quaternion { return _C(this, -12, undefined) as Quaternion; }
+
+    not(): boolean { return _C(this, -24, undefined) as boolean; }
+
+    /**
+     * Multiplies each component of the {@link Quaternion} by the right {@link int} value.
+     * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+     */
+    mul(other: number | Vector3 | Quaternion): Quaternion { return _C(this, -9, other) as Quaternion; }
+
+    /**
+     * Divides each component of the {@link Quaternion} by the right {@link int} value.
+     * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+     */
+    div(other: number): Quaternion { return _C(this, -10, other) as Quaternion; }
+
+    /**
+     * Adds each component of the left {@link Quaternion} to the right {@link Quaternion}.
+     * This operation is not meaningful on its own, but it can be used as a part of a larger expression, such as approximating an intermediate rotation between two nearby rotations.
+     */
+    add(other: Quaternion): Quaternion { return _C(this, -7, other) as Quaternion; }
+
+    /**
+     * Subtracts each component of the left {@link Quaternion} by the right {@link Quaternion}.
+     * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+     */
+    sub(other: Quaternion): Quaternion { return _C(this, -8, other) as Quaternion; }
+
+    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
+
+    static readonly name = _R(15, Quaternion);
+}

package/gen/value-types/Rect2.ts

@@ -0,0 +1,182 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
+import type { Rect2i, Transform2D, Vector2 } from '../value-types/index.ts';
+
+/**
+ * The {@link Rect2} built-in {@link Variant} type represents an axis-aligned rectangle in a 2D space. It is defined by its {@link position} and {@link size}, which are {@link Vector2}. It is frequently used for fast overlap tests (see {@link intersects}). Although {@link Rect2} itself is axis-aligned, it can be combined with {@link Transform2D} to represent a rotated or skewed rectangle.
+ * For integer coordinates, use {@link Rect2i}. The 3D equivalent to {@link Rect2} is {@link AABB}.
+ * **Note:** Negative values for {@link size} are not supported. With negative size, most {@link Rect2} methods do not work correctly. Use {@link abs} to get an equivalent {@link Rect2} with a non-negative size.
+ * **Note:** In a boolean context, a {@link Rect2} evaluates to `false` if both {@link position} and {@link size} are zero (equal to {@link Vector2.ZERO}). Otherwise, it always evaluates to `true`.
+ */
+export class Rect2 extends GodotVar {
+    /**
+     * The origin point. This is usually the top-left corner of the rectangle.
+     */
+    get position(): Vector2 { return _get(this, 9504) as Vector2; }
+    set position(v: Vector2) { _set(this, 9504, v); }
+
+    /**
+     * 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}.
+     */
+    get size(): Vector2 { return _get(this, 13608) as Vector2; }
+    set size(v: Vector2) { _set(this, 13608, v); }
+
+    /**
+     * 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}.
+     */
+    get end(): Vector2 { return _get(this, 3093) as Vector2; }
+    set end(v: Vector2) { _set(this, 3093, v); }
+
+    constructor();
+    constructor(from: Rect2);
+    constructor(from: Rect2i);
+    constructor(position: Vector2, size: Vector2);
+    constructor(x: number, y: number, width: number, height: number);
+    constructor(...args: any[]) { super(7, ...args); }
+
+    /**
+     * Returns the center point of the rectangle. This is the same as `position + (size / 2.0)`.
+     */
+    getCenter(): Vector2 { return _C(this, 4121) as Vector2; }
+
+    /**
+     * Returns the rectangle's area. This is equivalent to `size.x * size.y`. See also {@link hasArea}.
+     */
+    getArea(): number { return _C(this, 3789) as number; }
+
+    /**
+     * Returns `true` if this rectangle has positive width and height. See also {@link getArea}.
+     */
+    hasArea(): boolean { return _C(this, 7358) as 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.
+     */
+    hasPoint(point: Vector2): boolean { return _C(this, 7430, point) as boolean; }
+
+    /**
+     * Returns `true` if this rectangle and `rect` are approximately equal, by calling {@link Vector2.isEqualApprox} on the {@link position} and the {@link size}.
+     */
+    isEqualApprox(rect: Rect2): boolean { return _C(this, 7938, rect) as boolean; }
+
+    /**
+     * Returns `true` if this rectangle's values are finite, by calling {@link Vector2.isFinite} on the {@link position} and the {@link size}.
+     */
+    isFinite(): boolean { return _C(this, 7951) as boolean; }
+
+    /**
+     * Returns `true` if this rectangle overlaps with the `b` rectangle. The edges of both rectangles are excluded, unless `includeBorders` is `true`.
+     */
+    intersects(b: Rect2, includeBorders?: boolean /* = false */): boolean { return _C(this, 7707, b, includeBorders) as boolean; }
+
+    /**
+     * Returns `true` if this rectangle *completely* encloses the `b` rectangle.
+     */
+    encloses(b: Rect2): boolean { return _C(this, 3077, b) as boolean; }
+
+    /**
+     * Returns the intersection between this rectangle and `b`. If the rectangles do not intersect, returns an empty {@link Rect2}.
+     *
+     *
+     * ```gdscript
+     *
+     * var rect1 = Rect2(0, 0, 5, 10)
+     * var rect2 = Rect2(2, 0, 8, 4)
+     *
+     * var a = rect1.intersection(rect2) # a is Rect2(2, 0, 3, 4)
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** If you only need to know whether two rectangles are overlapping, use {@link intersects}, instead.
+     */
+    intersection(b: Rect2): Rect2 { return _C(this, 7705, b) as Rect2; }
+
+    /**
+     * Returns a {@link Rect2} that encloses both this rectangle and `b` around the edges. See also {@link encloses}.
+     */
+    merge(b: Rect2): Rect2 { return _C(this, 8850, b) as Rect2; }
+
+    /**
+     * Returns a copy of this rectangle expanded to align the edges with the given `to` point, if necessary.
+     *
+     *
+     * ```gdscript
+     *
+     * var rect = Rect2(0, 0, 5, 2)
+     *
+     * rect = rect.expand(Vector2(10, 0)) # rect is Rect2(0, 0, 10, 2)
+     * rect = rect.expand(Vector2(-5, 5)) # rect is Rect2(-5, 0, 15, 5)
+     *
+     * ```
+     */
+    expand(to: Vector2): Rect2 { return _C(this, 3187, to) as Rect2; }
+
+    /**
+     * 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.
+     */
+    getSupport(direction: Vector2): Vector2 { return _C(this, 6612, direction) as 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 growIndividual} and {@link growSide}.
+     *
+     *
+     * ```gdscript
+     *
+     * var a = Rect2(4, 4, 8, 8).grow(4) # a is Rect2(0, 0, 16, 16)
+     * var b = Rect2(0, 0, 8, 4).grow(2) # b is Rect2(-2, -2, 12, 8)
+     *
+     * ```
+     */
+    grow(amount: number): Rect2 { return _C(this, 7304, amount) as 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 growIndividual}.
+     */
+    growSide(side: number, amount: number): Rect2 { return _C(this, 7311, side, amount) as 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 growSide}.
+     */
+    growIndividual(left: number, top: number, right: number, bottom: number): Rect2 { return _C(this, 7309, left, top, right, bottom) as Rect2; }
+
+    /**
+     * 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.
+     *
+     *
+     * ```gdscript
+     *
+     * var rect = Rect2(25, 25, -100, -50)
+     * var absolute = rect.abs() # absolute is Rect2(-75, -25, 100, 50)
+     *
+     * ```
+     *
+     *
+     *
+     * **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 { return _C(this, 1053) as Rect2; }
+
+    equals(other: Variant | Rect2): boolean { return _C(this, -1, other) as boolean; }
+
+    notEquals(other: Variant | Rect2): boolean { return _C(this, -2, other) as boolean; }
+
+    not(): boolean { return _C(this, -24, undefined) as boolean; }
+
+    /**
+     * Inversely transforms (multiplies) the {@link Rect2} by the given {@link Transform2D} transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+     * `rect * transform` is equivalent to `transform.inverse() * rect`. See {@link Transform2D.inverse}.
+     * For transforming by inverse of an affine transformation (e.g. with scaling) `transform.affine_inverse() * rect` can be used instead. See {@link Transform2D.affineInverse}.
+     */
+    mul(other: Transform2D): Rect2 { return _C(this, -9, other) as Rect2; }
+
+    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
+
+    static readonly name = _R(7, Rect2);
+}

package/gen/value-types/Rect2i.ts

@@ -0,0 +1,161 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
+import type { Rect2, Vector2i } from '../value-types/index.ts';
+
+/**
+ * The {@link Rect2i} built-in {@link Variant} type represents an axis-aligned rectangle in a 2D space, using integer coordinates. It is defined by its {@link position} and {@link size}, which are {@link Vector2i}. Because it does not rotate, it is frequently used for fast overlap tests (see {@link intersects}).
+ * For floating-point coordinates, see {@link Rect2}.
+ * **Note:** Negative values for {@link size} are not supported. With negative size, most {@link Rect2i} methods do not work correctly. Use {@link abs} to get an equivalent {@link Rect2i} with a non-negative size.
+ * **Note:** In a boolean context, a {@link Rect2i} evaluates to `false` if both {@link position} and {@link size} are zero (equal to {@link Vector2i.ZERO}). Otherwise, it always evaluates to `true`.
+ */
+export class Rect2i extends GodotVar {
+    /**
+     * The origin point. This is usually the top-left corner of the rectangle.
+     */
+    get position(): Vector2i { return _get(this, 9504) as Vector2i; }
+    set position(v: Vector2i) { _set(this, 9504, v); }
+
+    /**
+     * 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}.
+     */
+    get size(): Vector2i { return _get(this, 13608) as Vector2i; }
+    set size(v: Vector2i) { _set(this, 13608, v); }
+
+    /**
+     * 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}.
+     */
+    get end(): Vector2i { return _get(this, 3093) as Vector2i; }
+    set end(v: Vector2i) { _set(this, 3093, v); }
+
+    constructor();
+    constructor(from: Rect2i);
+    constructor(from: Rect2);
+    constructor(position: Vector2i, size: Vector2i);
+    constructor(x: number, y: number, width: number, height: number);
+    constructor(...args: any[]) { super(8, ...args); }
+
+    /**
+     * 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}.
+     */
+    getCenter(): Vector2i { return _C(this, 4121) as Vector2i; }
+
+    /**
+     * Returns the rectangle's area. This is equivalent to `size.x * size.y`. See also {@link hasArea}.
+     */
+    getArea(): number { return _C(this, 3789) as number; }
+
+    /**
+     * Returns `true` if this rectangle has positive width and height. See also {@link getArea}.
+     */
+    hasArea(): boolean { return _C(this, 7358) as 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.
+     */
+    hasPoint(point: Vector2i): boolean { return _C(this, 7430, point) as boolean; }
+
+    /**
+     * Returns `true` if this rectangle overlaps with the `b` rectangle. The edges of both rectangles are excluded.
+     */
+    intersects(b: Rect2i): boolean { return _C(this, 7707, b) as boolean; }
+
+    /**
+     * Returns `true` if this {@link Rect2i} completely encloses another one.
+     */
+    encloses(b: Rect2i): boolean { return _C(this, 3077, b) as boolean; }
+
+    /**
+     * Returns the intersection between this rectangle and `b`. If the rectangles do not intersect, returns an empty {@link Rect2i}.
+     *
+     *
+     * ```gdscript
+     *
+     * var a = Rect2i(0, 0, 5, 10)
+     * var b = Rect2i(2, 0, 8, 4)
+     *
+     * var c = a.intersection(b) # c is Rect2i(2, 0, 3, 4)
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** If you only need to know whether two rectangles are overlapping, use {@link intersects}, instead.
+     */
+    intersection(b: Rect2i): Rect2i { return _C(this, 7705, b) as Rect2i; }
+
+    /**
+     * Returns a {@link Rect2i} that encloses both this rectangle and `b` around the edges. See also {@link encloses}.
+     */
+    merge(b: Rect2i): Rect2i { return _C(this, 8850, b) as Rect2i; }
+
+    /**
+     * Returns a copy of this rectangle expanded to align the edges with the given `to` point, if necessary.
+     *
+     *
+     * ```gdscript
+     *
+     * var rect = Rect2i(0, 0, 5, 2)
+     *
+     * rect = rect.expand(Vector2i(10, 0)) # rect is Rect2i(0, 0, 10, 2)
+     * rect = rect.expand(Vector2i(-5, 5)) # rect is Rect2i(-5, 0, 15, 5)
+     *
+     * ```
+     */
+    expand(to: Vector2i): Rect2i { return _C(this, 3187, to) as Rect2i; }
+
+    /**
+     * Returns a copy of this rectangle extended on all sides by the given `amount`. A negative `amount` shrinks the rectangle instead. See also {@link growIndividual} and {@link growSide}.
+     *
+     *
+     * ```gdscript
+     *
+     * var a = Rect2i(4, 4, 8, 8).grow(4) # a is Rect2i(0, 0, 16, 16)
+     * var b = Rect2i(0, 0, 8, 4).grow(2) # b is Rect2i(-2, -2, 12, 8)
+     *
+     * ```
+     */
+    grow(amount: number): Rect2i { return _C(this, 7304, amount) as 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 growIndividual}.
+     */
+    growSide(side: number, amount: number): Rect2i { return _C(this, 7311, side, amount) as 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 growSide}.
+     */
+    growIndividual(left: number, top: number, right: number, bottom: number): Rect2i { return _C(this, 7309, left, top, right, bottom) as Rect2i; }
+
+    /**
+     * 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.
+     *
+     *
+     * ```gdscript
+     *
+     * var rect = Rect2i(25, 25, -100, -50)
+     * var absolute = rect.abs() # absolute is Rect2i(-75, -25, 100, 50)
+     *
+     * ```
+     *
+     *
+     *
+     * **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 { return _C(this, 1053) as Rect2i; }
+
+    equals(other: Variant | Rect2i): boolean { return _C(this, -1, other) as boolean; }
+
+    notEquals(other: Variant | Rect2i): boolean { return _C(this, -2, other) as boolean; }
+
+    not(): boolean { return _C(this, -24, undefined) as boolean; }
+
+    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
+
+    static readonly name = _R(8, Rect2i);
+}