@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Vector4.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, PackedVector4Array, Variant } from '../heap-types/index.ts';
-import type { Projection, Vector4i } from '../value-types/index.ts';
+import type { Projection, Vector4i } from './index.ts';
 
 /**
  * A 4-element structure that can be used to represent 4D coordinates or any other quadruplet of numeric values.
@@ -11,275 +11,264 @@ import type { Projection, Vector4i } from '../value-types/index.ts';
  * See {@link Vector4i} for its integer counterpart.
  * **Note:** In a boolean context, a Vector4 will evaluate to `false` if it's equal to `Vector4(0, 0, 0, 0)`. Otherwise, a Vector4 will always evaluate to `true`.
  */
-export class Vector4 extends GodotVar {
-    /**
-     * The vector's X component. Also accessible by using the index position `[0]`.
-     */
-    get x(): number { return _get(this, 14941) as number; }
-    set x(v: number) { _set(this, 14941, v); }
-
-    /**
-     * The vector's Y component. Also accessible by using the index position `[1]`.
-     */
-    get y(): number { return _get(this, 14952) as number; }
-    set y(v: number) { _set(this, 14952, v); }
-
-    /**
-     * The vector's Z component. Also accessible by using the index position `[2]`.
-     */
-    get z(): number { return _get(this, 14956) as number; }
-    set z(v: number) { _set(this, 14956, v); }
-
-    /**
-     * The vector's W component. Also accessible by using the index position `[3]`.
-     */
-    get w(): number { return _get(this, 14833) as number; }
-    set w(v: number) { _set(this, 14833, v); }
-
-    constructor();
-    constructor(from: Vector4);
-    constructor(from: Vector4i);
-    constructor(x: number, y: number, z: number, w: number);
-    constructor(...args: any[]) { super(12, ...args); }
-
-    /**
-     * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_W}.
-     */
-    minAxisIndex(): number { return _C(this, 8911) as number; }
-
-    /**
-     * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
-     */
-    maxAxisIndex(): number { return _C(this, 8806) as number; }
-
-    /**
-     * Returns the length (magnitude) of this vector.
-     */
-    length(): number { return _C(this, 8546) as number; }
-
-    /**
-     * Returns the squared length (squared magnitude) of this vector.
-     * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
-     */
-    lengthSquared(): number { return _C(this, 8547) as number; }
-
-    /**
-     * Returns a new vector with all components in absolute values (i.e. positive).
-     */
-    abs(): Vector4 { return _C(this, 1053) as Vector4; }
-
-    /**
-     * Returns a new vector with each component set to `1.0` if it's positive, `-1.0` if it's negative, and `0.0` if it's zero. The result is identical to calling {@link sign} on each component.
-     */
-    sign(): Vector4 { return _C(this, 13597) as Vector4; }
-
-    /**
-     * Returns a new vector with all components rounded down (towards negative infinity).
-     */
-    floor(): Vector4 { return _C(this, 3335) as Vector4; }
-
-    /**
-     * Returns a new vector with all components rounded up (towards positive infinity).
-     */
-    ceil(): Vector4 { return _C(this, 2156) as Vector4; }
-
-    /**
-     * Returns a new vector with all components rounded to the nearest integer, with halfway cases rounded away from zero.
-     */
-    round(): Vector4 { return _C(this, 10166) as Vector4; }
-
-    /**
-     * Returns the result of the linear interpolation between this vector and `to` by amount `weight`. `weight` is on the range of `0.0` to `1.0`, representing the amount of interpolation.
-     */
-    lerp(to: Vector4, weight: number): Vector4 { return _C(this, 8548, to, weight) as Vector4; }
-
-    /**
-     * Performs a cubic interpolation between this vector and `b` using `preA` and `postB` as handles, and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
-     */
-    cubicInterpolate(b: Vector4, preA: Vector4, postB: Vector4, weight: number): Vector4 { return _C(this, 2590, b, preA, postB, weight) as Vector4; }
-
-    /**
-     * Performs a cubic interpolation between this vector and `b` using `preA` and `postB` as handles, and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
-     * It can perform smoother interpolation than {@link cubicInterpolate} by the time values.
-     */
-    cubicInterpolateInTime(b: Vector4, preA: Vector4, postB: Vector4, weight: number, bT: number, preAT: number, postBT: number): Vector4 { return _C(this, 2593, b, preA, postB, weight, bT, preAT, postBT) as Vector4; }
-
-    /**
-     * Returns a vector composed of the {@link fposmod} of this vector's components and `mod`.
-     */
-    posmod(mod: number): Vector4 { return _C(this, 9518, mod) as Vector4; }
-
-    /**
-     * Returns a vector composed of the {@link fposmod} of this vector's components and `modv`'s components.
-     */
-    posmodv(modv: Vector4): Vector4 { return _C(this, 9519, modv) as Vector4; }
-
-    /**
-     * Returns a new vector with each component snapped to the nearest multiple of the corresponding component in `step`. This can also be used to round the components to an arbitrary number of decimals.
-     */
-    snapped(step: Vector4): Vector4 { return _C(this, 13674, step) as Vector4; }
-
-    /**
-     * Returns a new vector with each component snapped to the nearest multiple of `step`. This can also be used to round the components to an arbitrary number of decimals.
-     */
-    snappedf(step: number): Vector4 { return _C(this, 13675, step) as Vector4; }
-
-    /**
-     * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
-     */
-    clamp(min: Vector4, max: Vector4): Vector4 { return _C(this, 2202, min, max) as Vector4; }
-
-    /**
-     * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
-     */
-    clampf(min: number, max: number): Vector4 { return _C(this, 2205, min, max) as Vector4; }
-
-    /**
-     * Returns the result of scaling the vector to unit length. Equivalent to `v / v.length()`. Returns `(0, 0, 0, 0)` if `v.length() == 0`. See also {@link isNormalized}.
-     * **Note:** This function may return incorrect values if the input vector length is near zero.
-     */
-    normalized(): Vector4 { return _C(this, 9103) as Vector4; }
-
-    /**
-     * Returns `true` if the vector is normalized, i.e. its length is approximately equal to 1.
-     */
-    isNormalized(): boolean { return _C(this, 8138) as boolean; }
-
-    /**
-     * Returns the normalized vector pointing from this vector to `to`. This is equivalent to using `(b - a).normalized()`.
-     */
-    directionTo(to: Vector4): Vector4 { return _C(this, 2792, to) as Vector4; }
-
-    /**
-     * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
-     */
-    distanceTo(to: Vector4): number { return _C(this, 2850, to) as number; }
-
-    /**
-     * Returns the squared [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
-     * This method runs faster than {@link distanceTo}, so prefer it if you need to compare vectors or need the squared distance for some formula.
-     */
-    distanceSquaredTo(to: Vector4): number { return _C(this, 2849, to) as number; }
-
-    /**
-     * Returns the dot product of this vector and `with`.
-     */
-    dot(_with: Vector4): number { return _C(this, 2871, _with) as number; }
-
-    /**
-     * Returns the inverse of the vector. This is the same as `Vector4(1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w)`.
-     */
-    inverse(): Vector4 { return _C(this, 7714) as Vector4; }
-
-    /**
-     * Returns `true` if this vector and `to` are approximately equal, by running {@link isEqualApprox} on each component.
-     */
-    isEqualApprox(to: Vector4): boolean { return _C(this, 7938, to) as boolean; }
-
-    /**
-     * Returns `true` if this vector's values are approximately zero, by running {@link isZeroApprox} on each component.
-     * This method is faster than using {@link isEqualApprox} with one value as a zero vector.
-     */
-    isZeroApprox(): boolean { return _C(this, 8459) as boolean; }
-
-    /**
-     * Returns `true` if this vector is finite, by calling {@link isFinite} on each component.
-     */
-    isFinite(): boolean { return _C(this, 7951) as boolean; }
-
-    /**
-     * Returns the component-wise minimum of this and `with`, equivalent to `Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w))`.
-     */
-    min(_with: Vector4): Vector4 { return _C(this, 8910, _with) as Vector4; }
-
-    /**
-     * Returns the component-wise minimum of this and `with`, equivalent to `Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with))`.
-     */
-    minf(_with: number): Vector4 { return _C(this, 8921, _with) as Vector4; }
-
-    /**
-     * Returns the component-wise maximum of this and `with`, equivalent to `Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w))`.
-     */
-    max(_with: Vector4): Vector4 { return _C(this, 8804, _with) as Vector4; }
-
-    /**
-     * Returns the component-wise maximum of this and `with`, equivalent to `Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with))`.
-     */
-    maxf(_with: number): Vector4 { return _C(this, 8839, _with) as Vector4; }
-
-    equals(other: Variant | Vector4): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Vector4): boolean { return _C(this, -2, other) as boolean; }
-
-    /**
-     * Returns the negative value of the {@link Vector4}. This is the same as writing `Vector4(-v.x, -v.y, -v.z, -v.w)`. This operation flips the direction of the vector while keeping the same magnitude. With floats, the number zero can be either positive or negative.
-     */
-    neg(): Vector4 { return _C(this, -11, undefined) as Vector4; }
-
-    /**
-     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
-     */
-    pos(): Vector4 { return _C(this, -12, undefined) as Vector4; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies each component of the {@link Vector4} by the given {@link int}.
-     */
-    mul(other: number | Vector4 | Projection): Vector4 { return _C(this, -9, other) as Vector4; }
-
-    /**
-     * Divides each component of the {@link Vector4} by the given {@link int}.
-     */
-    div(other: number | Vector4): Vector4 { return _C(this, -10, other) as Vector4; }
-
-    /**
-     * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is less than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
-     * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
-     */
-    lessThan(other: Vector4): boolean { return _C(this, -3, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is less than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
-     * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
-     */
-    lessThanOrEqual(other: Vector4): boolean { return _C(this, -4, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is greater than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
-     * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
-     */
-    greaterThan(other: Vector4): boolean { return _C(this, -5, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is greater than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
-     * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
-     */
-    greaterThanOrEqual(other: Vector4): boolean { return _C(this, -6, other) as boolean; }
-
-    /**
-     * Adds each component of the {@link Vector4} by the components of the given {@link Vector4}.
-     *
-     * ```text
-     *
-     * print(Vector4(10, 20, 30, 40) + Vector4(3, 4, 5, 6)) # Prints (13.0, 24.0, 35.0, 46.0)
-     *
-     * ```
-     */
-    add(other: Vector4): Vector4 { return _C(this, -7, other) as Vector4; }
-
-    /**
-     * Subtracts each component of the {@link Vector4} by the components of the given {@link Vector4}.
-     *
-     * ```text
-     *
-     * print(Vector4(10, 20, 30, 40) - Vector4(3, 4, 5, 6)) # Prints (7.0, 16.0, 25.0, 34.0)
-     *
-     * ```
-     */
-    sub(other: Vector4): Vector4 { return _C(this, -8, other) as Vector4; }
-
-    contains(other: GodotDictionary | GodotArray | PackedVector4Array): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(12, Vector4);
-}
+export type Vector4 = [x: number, y: number, z: number, w: number];
+
+/**
+ * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_W}.
+ */
+export function minAxisIndex(self: Vector4): number { return _V(12, 8911, self) as number; }
+
+/**
+ * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
+ */
+export function maxAxisIndex(self: Vector4): number { return _V(12, 8806, self) as number; }
+
+/**
+ * Returns the length (magnitude) of this vector.
+ */
+export function length(self: Vector4): number { return _V(12, 8546, self) as number; }
+
+/**
+ * Returns the squared length (squared magnitude) of this vector.
+ * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+ */
+export function lengthSquared(self: Vector4): number { return _V(12, 8547, self) as number; }
+
+/**
+ * Returns a new vector with all components in absolute values (i.e. positive).
+ */
+export function abs(self: Vector4): Vector4 { return _V(12, 1053, self) as Vector4; }
+
+/**
+ * Returns a new vector with each component set to `1.0` if it's positive, `-1.0` if it's negative, and `0.0` if it's zero. The result is identical to calling {@link sign} on each component.
+ */
+export function sign(self: Vector4): Vector4 { return _V(12, 13597, self) as Vector4; }
+
+/**
+ * Returns a new vector with all components rounded down (towards negative infinity).
+ */
+export function floor(self: Vector4): Vector4 { return _V(12, 3335, self) as Vector4; }
+
+/**
+ * Returns a new vector with all components rounded up (towards positive infinity).
+ */
+export function ceil(self: Vector4): Vector4 { return _V(12, 2156, self) as Vector4; }
+
+/**
+ * Returns a new vector with all components rounded to the nearest integer, with halfway cases rounded away from zero.
+ */
+export function round(self: Vector4): Vector4 { return _V(12, 10166, self) as Vector4; }
+
+/**
+ * Returns the result of the linear interpolation between this vector and `to` by amount `weight`. `weight` is on the range of `0.0` to `1.0`, representing the amount of interpolation.
+ */
+export function lerp(self: Vector4, to: Vector4, weight: number): Vector4 { return _V(12, 8548, self, to, weight) as Vector4; }
+
+/**
+ * Performs a cubic interpolation between this vector and `b` using `preA` and `postB` as handles, and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
+ */
+export function cubicInterpolate(self: Vector4, b: Vector4, preA: Vector4, postB: Vector4, weight: number): Vector4 { return _V(12, 2590, self, b, preA, postB, weight) as Vector4; }
+
+/**
+ * Performs a cubic interpolation between this vector and `b` using `preA` and `postB` as handles, and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
+ * It can perform smoother interpolation than {@link cubicInterpolate} by the time values.
+ */
+export function cubicInterpolateInTime(self: Vector4, b: Vector4, preA: Vector4, postB: Vector4, weight: number, bT: number, preAT: number, postBT: number): Vector4 { return _V(12, 2593, self, b, preA, postB, weight, bT, preAT, postBT) as Vector4; }
+
+/**
+ * Returns a vector composed of the {@link fposmod} of this vector's components and `mod`.
+ */
+export function posmod(self: Vector4, mod: number): Vector4 { return _V(12, 9518, self, mod) as Vector4; }
+
+/**
+ * Returns a vector composed of the {@link fposmod} of this vector's components and `modv`'s components.
+ */
+export function posmodv(self: Vector4, modv: Vector4): Vector4 { return _V(12, 9519, self, modv) as Vector4; }
+
+/**
+ * Returns a new vector with each component snapped to the nearest multiple of the corresponding component in `step`. This can also be used to round the components to an arbitrary number of decimals.
+ */
+export function snapped(self: Vector4, step: Vector4): Vector4 { return _V(12, 13674, self, step) as Vector4; }
+
+/**
+ * Returns a new vector with each component snapped to the nearest multiple of `step`. This can also be used to round the components to an arbitrary number of decimals.
+ */
+export function snappedf(self: Vector4, step: number): Vector4 { return _V(12, 13675, self, step) as Vector4; }
+
+/**
+ * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
+ */
+export function clamp(self: Vector4, min: Vector4, max: Vector4): Vector4 { return _V(12, 2202, self, min, max) as Vector4; }
+
+/**
+ * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
+ */
+export function clampf(self: Vector4, min: number, max: number): Vector4 { return _V(12, 2205, self, min, max) as Vector4; }
+
+/**
+ * Returns the result of scaling the vector to unit length. Equivalent to `v / v.length()`. Returns `(0, 0, 0, 0)` if `v.length() == 0`. See also {@link isNormalized}.
+ * **Note:** This function may return incorrect values if the input vector length is near zero.
+ */
+export function normalized(self: Vector4): Vector4 { return _V(12, 9103, self) as Vector4; }
+
+/**
+ * Returns `true` if the vector is normalized, i.e. its length is approximately equal to 1.
+ */
+export function isNormalized(self: Vector4): boolean { return _V(12, 8138, self) as boolean; }
+
+/**
+ * Returns the normalized vector pointing from this vector to `to`. This is equivalent to using `(b - a).normalized()`.
+ */
+export function directionTo(self: Vector4, to: Vector4): Vector4 { return _V(12, 2792, self, to) as Vector4; }
+
+/**
+ * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+ */
+export function distanceTo(self: Vector4, to: Vector4): number { return _V(12, 2850, self, to) as number; }
+
+/**
+ * Returns the squared [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+ * This method runs faster than {@link distanceTo}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+ */
+export function distanceSquaredTo(self: Vector4, to: Vector4): number { return _V(12, 2849, self, to) as number; }
+
+/**
+ * Returns the dot product of this vector and `with`.
+ */
+export function dot(self: Vector4, _with: Vector4): number { return _V(12, 2871, self, _with) as number; }
+
+/**
+ * Returns the inverse of the vector. This is the same as `Vector4(1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w)`.
+ */
+export function inverse(self: Vector4): Vector4 { return _V(12, 7714, self) as Vector4; }
+
+/**
+ * Returns `true` if this vector and `to` are approximately equal, by running {@link isEqualApprox} on each component.
+ */
+export function isEqualApprox(self: Vector4, to: Vector4): boolean { return _V(12, 7938, self, to) as boolean; }
+
+/**
+ * Returns `true` if this vector's values are approximately zero, by running {@link isZeroApprox} on each component.
+ * This method is faster than using {@link isEqualApprox} with one value as a zero vector.
+ */
+export function isZeroApprox(self: Vector4): boolean { return _V(12, 8459, self) as boolean; }
+
+/**
+ * Returns `true` if this vector is finite, by calling {@link isFinite} on each component.
+ */
+export function isFinite(self: Vector4): boolean { return _V(12, 7951, self) as boolean; }
+
+/**
+ * Returns the component-wise minimum of this and `with`, equivalent to `Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w))`.
+ */
+export function min(self: Vector4, _with: Vector4): Vector4 { return _V(12, 8910, self, _with) as Vector4; }
+
+/**
+ * Returns the component-wise minimum of this and `with`, equivalent to `Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with))`.
+ */
+export function minf(self: Vector4, _with: number): Vector4 { return _V(12, 8921, self, _with) as Vector4; }
+
+/**
+ * Returns the component-wise maximum of this and `with`, equivalent to `Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w))`.
+ */
+export function max(self: Vector4, _with: Vector4): Vector4 { return _V(12, 8804, self, _with) as Vector4; }
+
+/**
+ * Returns the component-wise maximum of this and `with`, equivalent to `Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with))`.
+ */
+export function maxf(self: Vector4, _with: number): Vector4 { return _V(12, 8839, self, _with) as Vector4; }
+
+export function equals(a: Vector4, b: Variant | Vector4): boolean { return _V(12, -1, a, b) as boolean; }
+
+export function notEquals(a: Vector4, b: Variant | Vector4): boolean { return _V(12, -2, a, b) as boolean; }
+
+/**
+ * Returns the negative value of the {@link Vector4}. This is the same as writing `Vector4(-v.x, -v.y, -v.z, -v.w)`. This operation flips the direction of the vector while keeping the same magnitude. With floats, the number zero can be either positive or negative.
+ */
+export function neg(self: Vector4): Vector4 { return _V(12, -11, self, undefined) as Vector4; }
+
+/**
+ * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
+ */
+export function pos(self: Vector4): Vector4 { return _V(12, -12, self, undefined) as Vector4; }
+
+export function not(self: Vector4): boolean { return _V(12, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies each component of the {@link Vector4} by the given {@link int}.
+ */
+export function mul(a: Vector4, b: number | Vector4 | Projection): Vector4 { return _V(12, -9, a, b) as Vector4; }
+
+/**
+ * Divides each component of the {@link Vector4} by the given {@link int}.
+ */
+export function div(a: Vector4, b: number | Vector4): Vector4 { return _V(12, -10, a, b) as Vector4; }
+
+/**
+ * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is less than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+ * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
+ */
+export function lessThan(a: Vector4, b: Vector4): boolean { return _V(12, -3, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is less than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+ * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
+ */
+export function lessThanOrEqual(a: Vector4, b: Vector4): boolean { return _V(12, -4, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is greater than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+ * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
+ */
+export function greaterThan(a: Vector4, b: Vector4): boolean { return _V(12, -5, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector4} vectors by first checking if the X value of the left vector is greater than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+ * **Note:** Vectors with `NAN` elements don't behave the same as other vectors. Therefore, the results from this operator may not be accurate if NaNs are included.
+ */
+export function greaterThanOrEqual(a: Vector4, b: Vector4): boolean { return _V(12, -6, a, b) as boolean; }
+
+/**
+ * Adds each component of the {@link Vector4} by the components of the given {@link Vector4}.
+ *
+ * ```text
+ *
+ * print(Vector4(10, 20, 30, 40) + Vector4(3, 4, 5, 6)) # Prints (13.0, 24.0, 35.0, 46.0)
+ *
+ * ```
+ */
+export function add(a: Vector4, b: Vector4): Vector4 { return _V(12, -7, a, b) as Vector4; }
+
+/**
+ * Subtracts each component of the {@link Vector4} by the components of the given {@link Vector4}.
+ *
+ * ```text
+ *
+ * print(Vector4(10, 20, 30, 40) - Vector4(3, 4, 5, 6)) # Prints (7.0, 16.0, 25.0, 34.0)
+ *
+ * ```
+ */
+export function sub(a: Vector4, b: Vector4): Vector4 { return _V(12, -8, a, b) as Vector4; }
+
+export function contains(a: Vector4, b: GodotDictionary | GodotArray | PackedVector4Array): boolean { return _V(12, -25, a, b) as boolean; }
+
+/**
+ * Constructs a default-initialized {@link Vector4} with all components set to `0`.
+ */
+export function create(): Vector4 { return _V(12, -4096, 0) as Vector4; }
+
+/**
+ * Constructs a {@link Vector4} as a copy of the given {@link Vector4}.
+ */
+export function fromVector4(from: Vector4): Vector4 { return _V(12, -4096, 1, from) as Vector4; }
+
+/**
+ * Constructs a new {@link Vector4} from the given {@link Vector4i}.
+ */
+export function fromVector4i(from: Vector4i): Vector4 { return _V(12, -4096, 2, from) as Vector4; }
+
+/**
+ * Returns a {@link Vector4} with the given components.
+ */
+export function fromXYZW(x: number, y: number, z: number, w: number): Vector4 { return _V(12, -4096, 3, x, y, z, w) as Vector4; }
+