@ringozz/godot 0.1.0

package/gen/value-types/AABB.ts

@@ -0,0 +1,288 @@
+// 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 { Plane, Transform3D, Vector3 } from '../value-types/index.ts';
+
+/**
+ * The {@link AABB} built-in {@link Variant} type represents an axis-aligned bounding box in a 3D space. It is defined by its {@link position} and {@link size}, which are {@link Vector3}. It is frequently used for fast overlap tests (see {@link intersects}). Although {@link AABB} itself is axis-aligned, it can be combined with {@link Transform3D} to represent a rotated or skewed bounding box.
+ * It uses floating-point coordinates. The 2D counterpart to {@link AABB} is {@link Rect2}. There is no version of {@link AABB} that uses integer coordinates.
+ * **Note:** Negative values for {@link size} are not supported. With negative size, most {@link AABB} methods do not work correctly. Use {@link abs} to get an equivalent {@link AABB} with a non-negative size.
+ * **Note:** In a boolean context, an {@link AABB} evaluates to `false` if both {@link position} and {@link size} are zero (equal to {@link Vector3.ZERO}). Otherwise, it always evaluates to `true`.
+ */
+export class AABB extends GodotVar {
+    /**
+     * The origin point. This is usually the corner on the bottom-left and forward of the bounding box.
+     */
+    get position(): Vector3 { return _get(this, 9504) as Vector3; }
+    set position(v: Vector3) { _set(this, 9504, v); }
+
+    /**
+     * 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}.
+     */
+    get size(): Vector3 { return _get(this, 13608) as Vector3; }
+    set size(v: Vector3) { _set(this, 13608, v); }
+
+    /**
+     * 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}.
+     */
+    get end(): Vector3 { return _get(this, 3093) as Vector3; }
+    set end(v: Vector3) { _set(this, 3093, v); }
+
+    constructor();
+    constructor(from: AABB);
+    constructor(position: Vector3, size: Vector3);
+    constructor(...args: any[]) { super(16, ...args); }
+
+    /**
+     * Returns an {@link AABB} equivalent to this bounding box, with its width, height, and depth modified to be non-negative values.
+     *
+     *
+     * ```gdscript
+     *
+     * var box = AABB(Vector3(5, 0, 5), Vector3(-20, -10, -5))
+     * var absolute = box.abs()
+     * print(absolute.position) # Prints (-15.0, -10.0, 0.0)
+     * print(absolute.size)     # Prints (20.0, 10.0, 5.0)
+     *
+     * ```
+     *
+     *
+     *
+     * **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 { return _C(this, 1053) as AABB; }
+
+    /**
+     * Returns the center point of the bounding box. This is the same as `position + (size / 2.0)`.
+     */
+    getCenter(): Vector3 { return _C(this, 4121) as Vector3; }
+
+    /**
+     * Returns the bounding box's volume. This is equivalent to `size.x * size.y * size.z`. See also {@link hasVolume}.
+     */
+    getVolume(): number { return _C(this, 7120) as number; }
+
+    /**
+     * Returns `true` if this bounding box's width, height, and depth are all positive. See also {@link getVolume}.
+     */
+    hasVolume(): boolean { return _C(this, 7485) as 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`.
+     */
+    hasSurface(): boolean { return _C(this, 7455) as boolean; }
+
+    /**
+     * 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.
+     */
+    hasPoint(point: Vector3): boolean { return _C(this, 7430, point) as boolean; }
+
+    /**
+     * Returns `true` if this bounding box and `aabb` are approximately equal, by calling {@link Vector3.isEqualApprox} on the {@link position} and the {@link size}.
+     */
+    isEqualApprox(aabb: AABB): boolean { return _C(this, 7938, aabb) as boolean; }
+
+    /**
+     * Returns `true` if this bounding box's values are finite, by calling {@link Vector3.isFinite} on the {@link position} and the {@link size}.
+     */
+    isFinite(): boolean { return _C(this, 7951) as boolean; }
+
+    /**
+     * Returns `true` if this bounding box overlaps with the box `with`. The edges of both boxes are *always* excluded.
+     */
+    intersects(_with: AABB): boolean { return _C(this, 7707, _with) as boolean; }
+
+    /**
+     * Returns `true` if this bounding box *completely* encloses the `with` box. The edges of both boxes are included.
+     *
+     *
+     * ```gdscript
+     *
+     * var a = AABB(Vector3(0, 0, 0), Vector3(4, 4, 4))
+     * var b = AABB(Vector3(1, 1, 1), Vector3(3, 3, 3))
+     * var c = AABB(Vector3(2, 2, 2), Vector3(8, 8, 8))
+     *
+     * print(a.encloses(a)) # Prints true
+     * print(a.encloses(b)) # Prints true
+     * print(a.encloses(c)) # Prints false
+     *
+     * ```
+     */
+    encloses(_with: AABB): boolean { return _C(this, 3077, _with) as boolean; }
+
+    /**
+     * Returns `true` if this bounding box is on both sides of the given `plane`.
+     */
+    intersectsPlane(plane: Plane): boolean { return _C(this, 7708, plane) as 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 hasSurface} and {@link hasVolume}).
+     *
+     *
+     * ```gdscript
+     *
+     * var box1 = AABB(Vector3(0, 0, 0), Vector3(5, 2, 8))
+     * var box2 = AABB(Vector3(2, 0, 2), Vector3(8, 4, 4))
+     *
+     * var intersection = box1.intersection(box2)
+     * print(intersection.position) # Prints (2.0, 0.0, 2.0)
+     * print(intersection.size)     # Prints (3.0, 2.0, 4.0)
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** If you only need to know whether two bounding boxes are intersecting, use {@link intersects}, instead.
+     */
+    intersection(_with: AABB): AABB { return _C(this, 7705, _with) as AABB; }
+
+    /**
+     * Returns an {@link AABB} that encloses both this bounding box and `with` around the edges. See also {@link encloses}.
+     */
+    merge(_with: AABB): AABB { return _C(this, 8850, _with) as AABB; }
+
+    /**
+     * Returns a copy of this bounding box expanded to align the edges with the given `toPoint`, if necessary.
+     *
+     *
+     * ```gdscript
+     *
+     * var box = AABB(Vector3(0, 0, 0), Vector3(5, 2, 5))
+     *
+     * box = box.expand(Vector3(10, 0, 0))
+     * print(box.position) # Prints (0.0, 0.0, 0.0)
+     * print(box.size)     # Prints (10.0, 2.0, 5.0)
+     *
+     * box = box.expand(Vector3(-5, 0, 5))
+     * print(box.position) # Prints (-5.0, 0.0, 0.0)
+     * print(box.size)     # Prints (15.0, 2.0, 5.0)
+     *
+     * ```
+     */
+    expand(toPoint: Vector3): AABB { return _C(this, 3187, toPoint) as AABB; }
+
+    /**
+     * Returns a copy of this bounding box extended on all sides by the given amount `by`. A negative amount shrinks the box instead.
+     *
+     *
+     * ```gdscript
+     *
+     * var a = AABB(Vector3(4, 4, 4), Vector3(8, 8, 8)).grow(4)
+     * print(a.position) # Prints (0.0, 0.0, 0.0)
+     * print(a.size)     # Prints (16.0, 16.0, 16.0)
+     *
+     * var b = AABB(Vector3(0, 0, 0), Vector3(8, 4, 2)).grow(2)
+     * print(b.position) # Prints (-2.0, -2.0, -2.0)
+     * print(b.size)     # Prints (12.0, 8.0, 6.0)
+     *
+     * ```
+     */
+    grow(by: number): AABB { return _C(this, 7304, by) as AABB; }
+
+    /**
+     * 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.
+     */
+    getSupport(direction: Vector3): Vector3 { return _C(this, 6612, direction) as 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}).
+     *
+     *
+     * ```gdscript
+     *
+     * var box = AABB(Vector3(0, 0, 0), Vector3(2, 4, 8))
+     *
+     * print(box.get_longest_axis())       # Prints (0.0, 0.0, 1.0)
+     * print(box.get_longest_axis_index()) # Prints 2
+     * print(box.get_longest_axis_size())  # Prints 8.0
+     *
+     * ```
+     *
+     *
+     *
+     * See also {@link getLongestAxisIndex} and {@link getLongestAxisSize}.
+     */
+    getLongestAxis(): Vector3 { return _C(this, 5413) as 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 getLongestAxis}.
+     */
+    getLongestAxisIndex(): number { return _C(this, 5414) as number; }
+
+    /**
+     * Returns the longest dimension of this bounding box's {@link size}.
+     * For an example, see {@link getLongestAxis}.
+     */
+    getLongestAxisSize(): number { return _C(this, 5415) as number; }
+
+    /**
+     * 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}).
+     *
+     *
+     * ```gdscript
+     *
+     * var box = AABB(Vector3(0, 0, 0), Vector3(2, 4, 8))
+     *
+     * print(box.get_shortest_axis())       # Prints (1.0, 0.0, 0.0)
+     * print(box.get_shortest_axis_index()) # Prints 0
+     * print(box.get_shortest_axis_size())  # Prints 2.0
+     *
+     * ```
+     *
+     *
+     *
+     * See also {@link getShortestAxisIndex} and {@link getShortestAxisSize}.
+     */
+    getShortestAxis(): Vector3 { return _C(this, 6379) as 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 getShortestAxis}.
+     */
+    getShortestAxisIndex(): number { return _C(this, 6380) as number; }
+
+    /**
+     * Returns the shortest dimension of this bounding box's {@link size}.
+     * For an example, see {@link getShortestAxis}.
+     */
+    getShortestAxisSize(): number { return _C(this, 6381) as number; }
+
+    /**
+     * 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}.
+     */
+    getEndpoint(idx: number): Vector3 { return _C(this, 4667, idx) as Vector3; }
+
+    /**
+     * 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`.
+     */
+    intersectsSegment(from: Vector3, to: Vector3): Variant { return _C(this, 7710, from, to) as Variant; }
+
+    /**
+     * 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.
+     */
+    intersectsRay(from: Vector3, dir: Vector3): Variant { return _C(this, 7709, from, dir) as Variant; }
+
+    equals(other: Variant | AABB): boolean { return _C(this, -1, other) as boolean; }
+
+    notEquals(other: Variant | AABB): boolean { return _C(this, -2, other) as boolean; }
+
+    not(): boolean { return _C(this, -24, undefined) as boolean; }
+
+    /**
+     * Inversely transforms (multiplies) the {@link AABB} by the given {@link Transform3D} transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+     * `aabb * transform` is equivalent to `transform.inverse() * aabb`. See {@link Transform3D.inverse}.
+     * For transforming by inverse of an affine transformation (e.g. with scaling) `transform.affine_inverse() * aabb` can be used instead. See {@link Transform3D.affineInverse}.
+     */
+    mul(other: Transform3D): AABB { return _C(this, -9, other) as AABB; }
+
+    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
+
+    static readonly name = _R(16, AABB);
+}

package/gen/value-types/Basis.ts

@@ -0,0 +1,283 @@
+// 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 { Quaternion, Vector3 } from '../value-types/index.ts';
+
+/**
+ * The {@link Basis} built-in {@link Variant} type is a 3×3 [matrix](https://en.wikipedia.org/wiki/Matrix_(mathematics)) used to represent 3D rotation, scale, and shear. It is frequently used within a {@link Transform3D}.
+ * A {@link Basis} is composed by 3 axis vectors, each representing a column of the matrix: {@link x}, {@link y}, and {@link z}. The length of each axis ({@link Vector3.length}) influences the basis's scale, while the direction of all axes influence the rotation. Usually, these axes are perpendicular to one another. However, when you rotate any axis individually, the basis becomes sheared. Applying a sheared basis to a 3D model will make the model appear distorted.
+ * A {@link Basis} is:
+ * - **Orthogonal** if its axes are perpendicular to each other.
+ * - **Normalized** if the length of every axis is `1.0`.
+ * - **Uniform** if all axes share the same length (see {@link getScale}).
+ * - **Orthonormal** if it is both orthogonal and normalized, which allows it to only represent rotations (see {@link orthonormalized}).
+ * - **Conformal** if it is both orthogonal and uniform, which ensures it is not distorted.
+ * For a general introduction, see the [Matrices and transforms]($DOCS_URL/tutorials/math/matrices_and_transforms.html) tutorial.
+ * **Note:** Godot uses a [right-handed coordinate system](https://en.wikipedia.org/wiki/Right-hand_rule), which is a common standard. For directions, the convention for built-in types like {@link Camera3D} is for -Z to point forward (+X is right, +Y is up, and +Z is back). Other objects may use different direction conventions. For more information, see the [3D asset direction conventions]($DOCS_URL/tutorials/assets_pipeline/importing_3d_scenes/model_export_considerations.html#d-asset-direction-conventions) tutorial.
+ * **Note:** The basis matrices are exposed as [column-major](https://www.mindcontrol.org/~hplus/graphics/matrix-layout.html) order, which is the same as OpenGL. However, they are stored internally in row-major order, which is the same as DirectX.
+ * **Note:** In a boolean context, a basis will evaluate to `false` if it's equal to {@link IDENTITY}. Otherwise, a basis will always evaluate to `true`.
+ */
+export class Basis extends GodotVar {
+    /**
+     * The basis's X axis, and the column `0` of the matrix.
+     * On the identity basis, this vector points right ({@link Vector3.RIGHT}).
+     */
+    get x(): Vector3 { return _get(this, 14941) as Vector3; }
+    set x(v: Vector3) { _set(this, 14941, v); }
+
+    /**
+     * The basis's Y axis, and the column `1` of the matrix.
+     * On the identity basis, this vector points up ({@link Vector3.UP}).
+     */
+    get y(): Vector3 { return _get(this, 14952) as Vector3; }
+    set y(v: Vector3) { _set(this, 14952, v); }
+
+    /**
+     * The basis's Z axis, and the column `2` of the matrix.
+     * On the identity basis, this vector points back ({@link Vector3.BACK}).
+     */
+    get z(): Vector3 { return _get(this, 14956) as Vector3; }
+    set z(v: Vector3) { _set(this, 14956, v); }
+
+    constructor();
+    constructor(from: Basis);
+    constructor(from: Quaternion);
+    constructor(axis: Vector3, angle: number);
+    constructor(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3);
+    constructor(...args: any[]) { super(17, ...args); }
+
+    /**
+     * Returns the [inverse of this basis's matrix](https://en.wikipedia.org/wiki/Invertible_matrix).
+     */
+    inverse(): Basis { return _C(this, 7714) as Basis; }
+
+    /**
+     * Returns the transposed version of this basis. This turns the basis matrix's columns into rows, and its rows into columns.
+     *
+     *
+     * ```gdscript
+     *
+     * var my_basis = Basis(
+     * 	Vector3(1, 2, 3),
+     * 	Vector3(4, 5, 6),
+     * 	Vector3(7, 8, 9)
+     * )
+     * my_basis = my_basis.transposed()
+     *
+     * print(my_basis.x) # Prints (1.0, 4.0, 7.0)
+     * print(my_basis.y) # Prints (2.0, 5.0, 8.0)
+     * print(my_basis.z) # Prints (3.0, 6.0, 9.0)
+     *
+     * ```
+     */
+    transposed(): Basis { return _C(this, 14405) as Basis; }
+
+    /**
+     * Returns the orthonormalized version of this basis. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the axes have a length of `1.0`), which also means it can only represent a rotation.
+     * It is often useful to call this method to avoid rounding errors on a rotating basis:
+     *
+     *
+     * ```gdscript
+     *
+     * # Rotate this Node3D every frame.
+     * func _process(delta):
+     * 	basis = basis.rotated(Vector3.UP, TAU * delta)
+     * 	basis = basis.rotated(Vector3.RIGHT, TAU * delta)
+     * 	basis = basis.orthonormalized()
+     *
+     * ```
+     */
+    orthonormalized(): Basis { return _C(this, 9230) as Basis; }
+
+    /**
+     * Returns the [determinant](https://en.wikipedia.org/wiki/Determinant) of this basis's matrix. For advanced math, this number can be used to determine a few attributes:
+     * - If the determinant is exactly `0.0`, the basis is not invertible (see {@link inverse}).
+     * - If the determinant is a negative number, the basis represents a negative scale.
+     * **Note:** If the basis's scale is the same for every axis, its determinant is always that scale by the power of 3.
+     */
+    determinant(): number { return _C(this, 2773) as number; }
+
+    /**
+     * Returns a copy of this basis rotated around the given `axis` by the given `angle` (in radians).
+     * The `axis` must be a normalized vector (see {@link Vector3.normalized}). If `angle` is positive, the basis is rotated counter-clockwise around the axis.
+     *
+     *
+     * ```gdscript
+     *
+     * var my_basis = Basis.IDENTITY
+     * var angle = TAU / 2
+     *
+     * my_basis = my_basis.rotated(Vector3.UP, angle)    # Rotate around the up axis (yaw).
+     * my_basis = my_basis.rotated(Vector3.RIGHT, angle) # Rotate around the right axis (pitch).
+     * my_basis = my_basis.rotated(Vector3.BACK, angle)  # Rotate around the back axis (roll).
+     *
+     * ```
+     */
+    rotated(axis: Vector3, angle: number): Basis { return _C(this, 10144, axis, angle) as Basis; }
+
+    /**
+     * Returns this basis with each axis's components scaled by the given `scale`'s components.
+     * The basis matrix's rows are multiplied by `scale`'s components. This operation is a global scale (relative to the parent).
+     *
+     *
+     * ```gdscript
+     *
+     * var my_basis = Basis(
+     * 	Vector3(1, 1, 1),
+     * 	Vector3(2, 2, 2),
+     * 	Vector3(3, 3, 3)
+     * )
+     * my_basis = my_basis.scaled(Vector3(0, 2, -2))
+     *
+     * print(my_basis.x) # Prints (0.0, 2.0, -2.0)
+     * print(my_basis.y) # Prints (0.0, 4.0, -4.0)
+     * print(my_basis.z) # Prints (0.0, 6.0, -6.0)
+     *
+     * ```
+     */
+    scaled(scale: Vector3): Basis { return _C(this, 10232, scale) as Basis; }
+
+    /**
+     * Returns this basis with each axis scaled by the corresponding component in the given `scale`.
+     * The basis matrix's columns are multiplied by `scale`'s components. This operation is a local scale (relative to self).
+     *
+     *
+     * ```gdscript
+     *
+     * var my_basis = Basis(
+     *     Vector3(1, 1, 1),
+     *     Vector3(2, 2, 2),
+     *     Vector3(3, 3, 3)
+     * )
+     * my_basis = my_basis.scaled_local(Vector3(0, 2, -2))
+     *
+     * print(my_basis.x) # Prints (0.0, 0.0, 0.0)
+     * print(my_basis.y) # Prints (4.0, 4.0, 4.0)
+     * print(my_basis.z) # Prints (-6.0, -6.0, -6.0)
+     *
+     * ```
+     */
+    scaledLocal(scale: Vector3): Basis { return _C(this, 10233, scale) as Basis; }
+
+    /**
+     * Returns the length of each axis of this basis, as a {@link Vector3}. If the basis is not sheared, this value is the scaling factor. It is not affected by rotation.
+     *
+     *
+     * ```gdscript
+     *
+     * var my_basis = Basis(
+     * 	Vector3(2, 0, 0),
+     * 	Vector3(0, 4, 0),
+     * 	Vector3(0, 0, 8)
+     * )
+     * # Rotating the Basis in any way preserves its scale.
+     * my_basis = my_basis.rotated(Vector3.UP, TAU / 2)
+     * my_basis = my_basis.rotated(Vector3.RIGHT, TAU / 4)
+     *
+     * print(my_basis.get_scale()) # Prints (2.0, 4.0, 8.0)
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** If the value returned by {@link determinant} is negative, the scale is also negative.
+     */
+    getScale(): Vector3 { return _C(this, 6236) as Vector3; }
+
+    /**
+     * Returns this basis's rotation as a {@link Vector3} of [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians. For the returned value:
+     * - The {@link Vector3.x} contains the angle around the {@link x} axis (pitch);
+     * - The {@link Vector3.y} contains the angle around the {@link y} axis (yaw);
+     * - The {@link Vector3.z} contains the angle around the {@link z} axis (roll).
+     * 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.
+     * **Note:** For this method to return correctly, the basis needs to be *orthonormal* (see {@link orthonormalized}).
+     * **Note:** Euler angles are much more intuitive but are not suitable for 3D math. Because of this, consider using the {@link getRotationQuaternion} method instead, which returns a {@link Quaternion}.
+     * **Note:** In the Inspector dock, a basis's rotation is often displayed in Euler angles (in degrees), as is the case with the {@link Node3D.rotation} property.
+     */
+    getEuler(order?: number /* = 2 */): Vector3 { return _C(this, 4689, order) as Vector3; }
+
+    /**
+     * Returns the transposed dot product between `with` and the {@link x} axis (see {@link transposed}).
+     * This is equivalent to `basis.x.dot(vector)`.
+     */
+    tdotx(_with: Vector3): number { return _C(this, 14141, _with) as number; }
+
+    /**
+     * Returns the transposed dot product between `with` and the {@link y} axis (see {@link transposed}).
+     * This is equivalent to `basis.y.dot(vector)`.
+     */
+    tdoty(_with: Vector3): number { return _C(this, 14142, _with) as number; }
+
+    /**
+     * Returns the transposed dot product between `with` and the {@link z} axis (see {@link transposed}).
+     * This is equivalent to `basis.z.dot(vector)`.
+     */
+    tdotz(_with: Vector3): number { return _C(this, 14143, _with) as number; }
+
+    /**
+     * Performs a spherical-linear interpolation with the `to` basis, given a `weight`. Both this basis and `to` should represent a rotation.
+     * **Example:** Smoothly rotate a {@link Node3D} to the target basis over time, with a {@link Tween}:
+     *
+     * ```text
+     *
+     * var start_basis = Basis.IDENTITY
+     * var target_basis = Basis.IDENTITY.rotated(Vector3.UP, TAU / 2)
+     *
+     * func _ready():
+     * 	create_tween().tween_method(interpolate, 0.0, 1.0, 5.0).set_trans(Tween.TRANS_EXPO)
+     *
+     * func interpolate(weight):
+     * 	basis = start_basis.slerp(target_basis, weight)
+     *
+     * ```
+     */
+    slerp(to: Basis, weight: number): Basis { return _C(this, 13656, to, weight) as Basis; }
+
+    /**
+     * Returns `true` if this basis is conformal. A conformal basis is both *orthogonal* (the axes are perpendicular to each other) and *uniform* (the axes share the same length). This method can be especially useful during physics calculations.
+     */
+    isConformal(): boolean { return _C(this, 7854) as boolean; }
+
+    /**
+     * Returns `true` if this basis and `b` are approximately equal, by calling {@link isEqualApprox} on all vector components.
+     */
+    isEqualApprox(b: Basis): boolean { return _C(this, 7938, b) as boolean; }
+
+    /**
+     * Returns `true` if this basis is finite, by calling {@link isFinite} on all vector components.
+     */
+    isFinite(): boolean { return _C(this, 7951) as boolean; }
+
+    /**
+     * Returns `true` if this basis is orthonormal. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the length of every axis is `1.0`). This method can be especially useful during physics calculations.
+     */
+    isOrthonormal(): boolean { return _C(this, 8158) as boolean; }
+
+    /**
+     * Returns this basis's rotation as a {@link Quaternion}.
+     * **Note:** Quaternions are much more suitable for 3D math but are less intuitive. For user interfaces, consider using the {@link getEuler} method, which returns Euler angles.
+     */
+    getRotationQuaternion(): Quaternion { return _C(this, 6214) as Quaternion; }
+
+    equals(other: Variant | Basis): boolean { return _C(this, -1, other) as boolean; }
+
+    notEquals(other: Variant | Basis): boolean { return _C(this, -2, other) as boolean; }
+
+    not(): boolean { return _C(this, -24, undefined) as boolean; }
+
+    /**
+     * Multiplies all components of the {@link Basis} by the given {@link int}. This affects the basis's scale uniformly, resizing all 3 axes by the `right` value.
+     */
+    mul(other: number | Vector3 | Basis): Basis { return _C(this, -9, other) as Basis; }
+
+    /**
+     * Divides all components of the {@link Basis} by the given {@link int}. This affects the basis's scale uniformly, resizing all 3 axes by the `right` value.
+     */
+    div(other: number): Basis { return _C(this, -10, other) as Basis; }
+
+    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
+
+    static readonly name = _R(17, Basis);
+}