@ringozz/godot 4.7.2-583 → 4.7.2-585

package/gen/value-types/AABB.ts

@@ -1,9 +1,9 @@
 // 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 { _V } from '../../src/runtime.ts';
 import type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
-import type { Plane, Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Plane, Transform3D, Vector3 } from './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.
@@ -11,278 +11,268 @@ import type { Plane, Transform3D, Vector3 } from '../value-types/index.ts';
  * **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);
-}
+export type AABB = [position: Vector3, size: Vector3];
+
+/**
+ * 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`.
+ */
+export function abs(self: AABB): AABB { return _V(16, 1053, self) as AABB; }
+
+/**
+ * Returns the center point of the bounding box. This is the same as `position + (size / 2.0)`.
+ */
+export function getCenter(self: AABB): Vector3 { return _V(16, 4121, self) as Vector3; }
+
+/**
+ * Returns the bounding box's volume. This is equivalent to `size.x * size.y * size.z`. See also {@link hasVolume}.
+ */
+export function getVolume(self: AABB): number { return _V(16, 7120, self) as number; }
+
+/**
+ * Returns `true` if this bounding box's width, height, and depth are all positive. See also {@link getVolume}.
+ */
+export function hasVolume(self: AABB): boolean { return _V(16, 7485, self) 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`.
+ */
+export function hasSurface(self: AABB): boolean { return _V(16, 7455, self) 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.
+ */
+export function hasPoint(self: AABB, point: Vector3): boolean { return _V(16, 7430, self, 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}.
+ */
+export function isEqualApprox(self: AABB, aabb: AABB): boolean { return _V(16, 7938, self, 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}.
+ */
+export function isFinite(self: AABB): boolean { return _V(16, 7951, self) as boolean; }
+
+/**
+ * Returns `true` if this bounding box overlaps with the box `with`. The edges of both boxes are *always* excluded.
+ */
+export function intersects(self: AABB, _with: AABB): boolean { return _V(16, 7707, self, _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
+ *
+ * ```
+ */
+export function encloses(self: AABB, _with: AABB): boolean { return _V(16, 3077, self, _with) as boolean; }
+
+/**
+ * Returns `true` if this bounding box is on both sides of the given `plane`.
+ */
+export function intersectsPlane(self: AABB, plane: Plane): boolean { return _V(16, 7708, self, 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.
+ */
+export function intersection(self: AABB, _with: AABB): AABB { return _V(16, 7705, self, _with) as AABB; }
+
+/**
+ * Returns an {@link AABB} that encloses both this bounding box and `with` around the edges. See also {@link encloses}.
+ */
+export function merge(self: AABB, _with: AABB): AABB { return _V(16, 8850, self, _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)
+ *
+ * ```
+ */
+export function expand(self: AABB, toPoint: Vector3): AABB { return _V(16, 3187, self, 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)
+ *
+ * ```
+ */
+export function grow(self: AABB, by: number): AABB { return _V(16, 7304, self, 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.
+ */
+export function getSupport(self: AABB, direction: Vector3): Vector3 { return _V(16, 6612, self, 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}.
+ */
+export function getLongestAxis(self: AABB): Vector3 { return _V(16, 5413, self) 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}.
+ */
+export function getLongestAxisIndex(self: AABB): number { return _V(16, 5414, self) as number; }
+
+/**
+ * Returns the longest dimension of this bounding box's {@link size}.
+ * For an example, see {@link getLongestAxis}.
+ */
+export function getLongestAxisSize(self: AABB): number { return _V(16, 5415, self) 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}.
+ */
+export function getShortestAxis(self: AABB): Vector3 { return _V(16, 6379, self) 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}.
+ */
+export function getShortestAxisIndex(self: AABB): number { return _V(16, 6380, self) as number; }
+
+/**
+ * Returns the shortest dimension of this bounding box's {@link size}.
+ * For an example, see {@link getShortestAxis}.
+ */
+export function getShortestAxisSize(self: AABB): number { return _V(16, 6381, self) 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}.
+ */
+export function getEndpoint(self: AABB, idx: number): Vector3 { return _V(16, 4667, self, 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`.
+ */
+export function intersectsSegment(self: AABB, from: Vector3, to: Vector3): Variant { return _V(16, 7710, self, 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.
+ */
+export function intersectsRay(self: AABB, from: Vector3, dir: Vector3): Variant { return _V(16, 7709, self, from, dir) as Variant; }
+
+export function equals(a: AABB, b: Variant | AABB): boolean { return _V(16, -1, a, b) as boolean; }
+
+export function notEquals(a: AABB, b: Variant | AABB): boolean { return _V(16, -2, a, b) as boolean; }
+
+export function not(self: AABB): boolean { return _V(16, -24, self, 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}.
+ */
+export function mul(a: AABB, b: Transform3D): AABB { return _V(16, -9, a, b) as AABB; }
+
+export function contains(a: AABB, b: GodotDictionary | GodotArray): boolean { return _V(16, -25, a, b) as boolean; }
+
+/**
+ * Constructs an {@link AABB} with its {@link position} and {@link size} set to {@link Vector3.ZERO}.
+ */
+export function create(): AABB { return _V(16, -4096, 0) as AABB; }
+
+/**
+ * Constructs an {@link AABB} as a copy of the given {@link AABB}.
+ */
+export function fromAABB(from: AABB): AABB { return _V(16, -4096, 1, from) as AABB; }
+
+/**
+ * Constructs an {@link AABB} by `position` and `size`.
+ */
+export function fromPositionSize(position: Vector3, size: Vector3): AABB { return _V(16, -4096, 2, position, size) as AABB; }
+